From 1d43e5e8078ce348c0af568ecbc5f6f3405c9daa Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Thu, 4 May 2023 01:50:11 +0800 Subject: [PATCH 01/34] feature(pu): add init league version of alphazero config and collector for tictactoe and gomoku --- lzero/entry/__init__.py | 1 + lzero/entry/train_alphazero_league.py | 245 ++++++++++ lzero/policy/alphazero.py | 2 + lzero/worker/__init__.py | 2 + lzero/worker/alphazero_collector.py | 2 + lzero/worker/alphazero_evaluator.py | 9 + lzero/worker/battle_alphazero_collector.py | 426 ++++++++++++++++++ .../config/gomoku_alphazero_league_config.py | 136 ++++++ zoo/board_games/gomoku/envs/gomoku_env.py | 4 +- .../tictactoe_alphazero_league_config.py | 134 ++++++ .../tictactoe/envs/tictactoe_env.py | 4 +- 11 files changed, 963 insertions(+), 2 deletions(-) create mode 100644 lzero/entry/train_alphazero_league.py create mode 100644 lzero/worker/battle_alphazero_collector.py create mode 100644 zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py create mode 100644 zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py diff --git a/lzero/entry/__init__.py b/lzero/entry/__init__.py index 352d29ddf..18edb2b8a 100644 --- a/lzero/entry/__init__.py +++ b/lzero/entry/__init__.py @@ -1,4 +1,5 @@ from .train_alphazero import train_alphazero +from .train_alphazero_league import train_alphazero_league from .eval_alphazero import eval_alphazero from .train_muzero import train_muzero from .eval_muzero import eval_muzero diff --git a/lzero/entry/train_alphazero_league.py b/lzero/entry/train_alphazero_league.py new file mode 100644 index 000000000..dd661d79b --- /dev/null +++ b/lzero/entry/train_alphazero_league.py @@ -0,0 +1,245 @@ +import copy +import copy +import logging +import os +import shutil +from functools import partial + +import torch +from ding.config import compile_config +from ding.envs import SyncSubprocessEnvManager +from ding.league import BaseLeague, ActivePlayer +from ding.policy import create_policy +from ding.utils import set_pkg_seed +from ding.worker import BaseLearner, create_buffer +from ding.worker import NaiveReplayBuffer +from easydict import EasyDict +from tensorboardX import SummaryWriter + +from lzero.policy.alphazero import AlphaZeroPolicy +from lzero.worker import AlphaZeroEvaluator +from lzero.worker import BattleAlphaZeroCollector + + +def win_loss_draw(episode_info): + """ + Overview: + Get win/loss/draw result from episode info + Arguments: + - episode_info (:obj:`list`): List of episode info + Returns: + - win_loss_result (:obj:`list`): List of win/loss/draw result + Examples: + >>> episode_info = [{'eval_episode_return': 1}, {'eval_episode_return': 0}, {'eval_episode_return': -1}] + >>> win_loss_draw(episode_info) + ['wins', 'draws', 'losses'] + """ + win_loss_result = [] + for e in episode_info: + if e['eval_episode_return'] == 1: + result = 'wins' + elif e['eval_episode_return'] == 0: + result = 'draws' + else: + result = 'losses' + win_loss_result.append(result) + + return win_loss_result + + +class AlphaZeroLeague(BaseLeague): + # override + def _get_job_info(self, player: ActivePlayer, eval_flag: bool = False) -> dict: + assert isinstance(player, ActivePlayer), player.__class__ + player_job_info = EasyDict(player.get_job(eval_flag)) + return { + 'agent_num': 2, + # home player_id + 'launch_player': player.player_id, + # include home and away player_id + 'player_id': [player.player_id, player_job_info.opponent.player_id], + 'checkpoint_path': [player.checkpoint_path, player_job_info.opponent.checkpoint_path], + 'player_active_flag': [isinstance(p, ActivePlayer) for p in [player, player_job_info.opponent]], + } + + # override + def _mutate_player(self, player: ActivePlayer): + # no mutate operation + pass + + # override + def _update_player(self, player: ActivePlayer, player_info: dict) -> None: + assert isinstance(player, ActivePlayer) + if 'learner_step' in player_info: + player.total_agent_step = player_info['learner_step'] + + # override + @staticmethod + def save_checkpoint(src_checkpoint_path: str, dst_checkpoint_path: str) -> None: + shutil.copy(src_checkpoint_path, dst_checkpoint_path) + + +def train_alphazero_league(cfg, Env, seed=0): + # prepare config + cfg = compile_config( + cfg, + SyncSubprocessEnvManager, + AlphaZeroPolicy, + BaseLearner, + BattleAlphaZeroCollector, + AlphaZeroEvaluator, + NaiveReplayBuffer, + save_cfg=True + ) + collector_env_num, evaluator_env_num = cfg.env.collector_env_num, cfg.env.evaluator_env_num + collector_env_cfg = copy.deepcopy(cfg.env) + evaluator_env_cfg = copy.deepcopy(cfg.env) + evaluator_env_cfg.battle_mode = 'eval_mode' + tb_logger = SummaryWriter(os.path.join('./{}/log/'.format(cfg.exp_name), 'serial')) + + # TODO(pu): use different replay buffer for different players + # create replay buffer + replay_buffer = create_buffer(cfg.policy.other.replay_buffer, tb_logger=tb_logger, exp_name=cfg.exp_name) + + # create league + league = AlphaZeroLeague(cfg.policy.league) + policies, learners, collectors = {}, {}, {} + + # create players + for player_id in league.active_players_ids: + policy = create_policy(cfg.policy, enable_field=['learn', 'collect', 'eval']) + policies[player_id] = policy + collector_env = SyncSubprocessEnvManager( + env_fn=[partial(Env, collector_env_cfg) for _ in range(collector_env_num)], cfg=cfg.env.manager + ) + collector_env.seed(seed) + + learners[player_id] = BaseLearner( + cfg.policy.learn.learner, + policy.learn_mode, + tb_logger, + exp_name=cfg.exp_name, + instance_name=player_id + '_learner' + ) + collectors[player_id] = BattleAlphaZeroCollector( + cfg.policy.collect.collector, + collector_env, [policy.collect_mode, policy.collect_mode], + tb_logger, + exp_name=cfg.exp_name, + instance_name=player_id + '_collector' + ) + + # create policy + policy = create_policy(cfg.policy, enable_field=['learn', 'collect', 'eval']) + main_key = [k for k in learners.keys() if k.startswith('main_player')][0] + main_player = league.get_player_by_id(main_key) + main_learner = learners[main_key] + main_collector = collectors[main_key] + + policies['historical'] = policy + + # create evaluator + evaluator_env = SyncSubprocessEnvManager( + env_fn=[partial(Env, evaluator_env_cfg) for _ in range(evaluator_env_num)], cfg=cfg.env.manager + ) + evaluator_env.seed(seed, dynamic_seed=False) + evaluator_cfg = copy.deepcopy(cfg.policy.eval.evaluator) + evaluator_cfg.stop_value = cfg.env.stop_value + evaluator = AlphaZeroEvaluator( + eval_freq=cfg.policy.eval_freq, + n_evaluator_episode=cfg.env.n_evaluator_episode, + stop_value=cfg.env.stop_value, + env=evaluator_env, + policy=policy.eval_mode, + tb_logger=tb_logger, + exp_name=cfg.exp_name, + instance_name='vs_bot_evaluator' + ) + + def load_checkpoint_fn(player_id: str, ckpt_path: str): + state_dict = torch.load(ckpt_path) + policies[player_id].learn_mode.load_state_dict(state_dict) + + league.load_checkpoint = load_checkpoint_fn + # snapshot the initial player as the first historical player + for player_id, player_ckpt_path in zip(league.active_players_ids, league.active_players_ckpts): + torch.save(policies[player_id].collect_mode.state_dict(), player_ckpt_path) + league.judge_snapshot(player_id, force=True) + + set_pkg_seed(seed, use_cuda=cfg.policy.cuda) + league_iter = 0 + while True: + if evaluator.should_eval(main_learner.train_iter): + stop_flag, eval_episode_info = evaluator.eval( + main_learner.save_checkpoint, main_learner.train_iter, main_collector.envstep + ) + win_loss_result = win_loss_draw(eval_episode_info) + + # set eval bot rating as 100. + main_player.rating = league.metric_env.rate_1vsC( + main_player.rating, league.metric_env.create_rating(mu=100, sigma=1e-8), win_loss_result + ) + if stop_flag: + break + + for player_id, player_ckpt_path in zip(league.active_players_ids, league.active_players_ckpts): + tb_logger.add_scalar( + 'league/{}_trueskill'.format(player_id), + league.get_player_by_id(player_id).rating.exposure, main_collector.envstep + ) + collector, learner = collectors[player_id], learners[player_id] + + job = league.get_job_info(player_id) + opponent_player_id = job['player_id'][1] + # print('job player: {}'.format(job['player_id'])) + if 'historical' in opponent_player_id: + opponent_policy = policies['historical'].collect_mode + opponent_path = job['checkpoint_path'][1] + opponent_policy.load_state_dict(torch.load(opponent_path, map_location='cpu')) + else: + opponent_policy = policies[opponent_player_id].collect_mode + + collector.reset_policy([policies[player_id].collect_mode, opponent_policy]) + + new_data, episode_info = collector.collect( + train_iter=learner.train_iter, n_episode=cfg.policy.n_episode + ) + # TODO(pu): new_data[1] + new_data = sum(new_data[0], []) + replay_buffer.push(new_data, cur_collector_envstep=collector.envstep) + # Learn policy from collected data + for i in range(cfg.policy.update_per_collect): + # Learner will train ``update_per_collect`` times in one iteration. + train_data = replay_buffer.sample(cfg.policy.batch_size, learner.train_iter) + if train_data is None: + logging.warning( + 'The data in replay_buffer is not sufficient to sample a mini-batch.' + 'continue to collect now ....' + ) + break + learner.train(train_data, collector.envstep) + + # update the learner_step for the current active player, i.e. the main player in most cases. + player_info = learner.learn_info + player_info['player_id'] = player_id + league.update_active_player(player_info) + league.judge_snapshot(player_id) + # set eval_flag=True to enable trueskill update + + win_loss_result = win_loss_draw(episode_info[0]) + + job_finish_info = { + 'eval_flag': True, + 'launch_player': job['launch_player'], + 'player_id': job['player_id'], + 'result': win_loss_result, + } + league.finish_job(job_finish_info) + + if league_iter % cfg.policy.league.log_freq == 0: + payoff_string = repr(league.payoff) + rank_string = league.player_rank(string=True) + tb_logger.add_text('payoff_step', payoff_string, main_collector.envstep) + tb_logger.add_text('rank_step', rank_string, main_collector.envstep) + + league_iter += 1 diff --git a/lzero/policy/alphazero.py b/lzero/policy/alphazero.py index 1418c3c25..101dd9e58 100644 --- a/lzero/policy/alphazero.py +++ b/lzero/policy/alphazero.py @@ -24,6 +24,8 @@ class AlphaZeroPolicy(Policy): # The default_config for AlphaZero policy. config = dict( + # (str) RL policy register name (refer to function "POLICY_REGISTRY"). + type='alphazero', model=dict( # (tuple) The stacked obs shape. observation_shape=(3, 6, 6), diff --git a/lzero/worker/__init__.py b/lzero/worker/__init__.py index b74e1e745..502176e63 100644 --- a/lzero/worker/__init__.py +++ b/lzero/worker/__init__.py @@ -2,3 +2,5 @@ from .alphazero_evaluator import AlphaZeroEvaluator from .muzero_collector import MuZeroCollector from .muzero_evaluator import MuZeroEvaluator + +from .battle_alphazero_collector import BattleAlphaZeroCollector diff --git a/lzero/worker/alphazero_collector.py b/lzero/worker/alphazero_collector.py index 6807e72a3..4bf0b8584 100644 --- a/lzero/worker/alphazero_collector.py +++ b/lzero/worker/alphazero_collector.py @@ -192,6 +192,7 @@ def collect(self, for env_id in ready_env_id: # create the new simulation env instances from the current collect env using the same env_config. simulation_envs[env_id] = self._env._env_fn[env_id]() + # ============================================================== # policy forward # ============================================================== @@ -200,6 +201,7 @@ def collect(self, # Interact with env. actions = {env_id: output['action'] for env_id, output in policy_output.items()} actions = to_ndarray(actions) + # ============================================================== # Interact with env. # ============================================================== diff --git a/lzero/worker/alphazero_evaluator.py b/lzero/worker/alphazero_evaluator.py index 653b533c9..8e96d2e29 100644 --- a/lzero/worker/alphazero_evaluator.py +++ b/lzero/worker/alphazero_evaluator.py @@ -18,6 +18,15 @@ class AlphaZeroEvaluator(ISerialEvaluator): Property: env, policy """ + config = dict( + # Evaluate every "eval_freq" training iterations. + eval_freq=1000, + render=dict( + # tensorboard video render is disabled by default + render_freq=-1, + mode='train_iter', + ) + ) def __init__( self, diff --git a/lzero/worker/battle_alphazero_collector.py b/lzero/worker/battle_alphazero_collector.py new file mode 100644 index 000000000..ee8002b16 --- /dev/null +++ b/lzero/worker/battle_alphazero_collector.py @@ -0,0 +1,426 @@ +from typing import Optional, Any, List, Tuple +from collections import namedtuple, deque +from easydict import EasyDict +import numpy as np +import torch + +from ding.envs import BaseEnvManager +from ding.utils import build_logger, EasyTimer, SERIAL_COLLECTOR_REGISTRY, dicts_to_lists +from ding.torch_utils import to_tensor, to_ndarray +from ding.worker.collector.base_serial_collector import ISerialCollector, CachePool, TrajBuffer, INF, to_tensor_transitions + + +@SERIAL_COLLECTOR_REGISTRY.register('episode_alphazero_battle') +class BattleAlphaZeroCollector(ISerialCollector): + """ + Overview: + Episode collector(n_episode) with two policy battle + Interfaces: + __init__, reset, reset_env, reset_policy, collect, close + Property: + envstep + """ + + config = dict(deepcopy_obs=False, transform_obs=False, collect_print_freq=100, get_train_sample=False) + + def __init__( + self, + cfg: EasyDict, + env: BaseEnvManager = None, + policy: List[namedtuple] = None, + tb_logger: 'SummaryWriter' = None, # noqa + exp_name: Optional[str] = 'default_experiment', + instance_name: Optional[str] = 'collector' + ) -> None: + """ + Overview: + Initialization method. + Arguments: + - cfg (:obj:`EasyDict`): Config dict + - env (:obj:`BaseEnvManager`): the subclass of vectorized env_manager(BaseEnvManager) + - policy (:obj:`List[namedtuple]`): the api namedtuple of collect_mode policy + - tb_logger (:obj:`SummaryWriter`): tensorboard handle + """ + self._exp_name = exp_name + self._instance_name = instance_name + self._collect_print_freq = cfg.collect_print_freq + self._deepcopy_obs = cfg.deepcopy_obs + self._transform_obs = cfg.transform_obs + self._cfg = cfg + self._timer = EasyTimer() + self._end_flag = False + + if tb_logger is not None: + self._logger, _ = build_logger( + path='./{}/log/{}'.format(self._exp_name, self._instance_name), name=self._instance_name, need_tb=False + ) + self._tb_logger = tb_logger + else: + self._logger, self._tb_logger = build_logger( + path='./{}/log/{}'.format(self._exp_name, self._instance_name), name=self._instance_name + ) + self._traj_len = float("inf") + self.reset(policy, env) + + def reset_env(self, _env: Optional[BaseEnvManager] = None) -> None: + """ + Overview: + Reset the environment. + If _env is None, reset the old environment. + If _env is not None, replace the old environment in the collector with the new passed \ + in environment and launch. + Arguments: + - env (:obj:`Optional[BaseEnvManager]`): instance of the subclass of vectorized \ + env_manager(BaseEnvManager) + """ + if _env is not None: + self._env = _env + self._env.launch() + self._env_num = self._env.env_num + else: + self._env.reset() + + def reset_policy(self, _policy: Optional[List[namedtuple]] = None) -> None: + """ + Overview: + Reset the policy. + If _policy is None, reset the old policy. + If _policy is not None, replace the old policy in the collector with the new passed in policy. + Arguments: + - policy (:obj:`Optional[List[namedtuple]]`): the api namedtuple of collect_mode policy + """ + assert hasattr(self, '_env'), "please set env first" + if _policy is not None: + assert len(_policy) == 2, "1v1 episode collector needs 2 policy, but found {}".format(len(_policy)) + self._policy = _policy + self._default_n_episode = _policy[0].get_attribute('cfg').collect.get('n_episode', None) + # self._unroll_len = _policy[0].get_attribute('unroll_len') + # self._on_policy = _policy[0].get_attribute('cfg').on_policy + self._traj_len = INF + self._logger.debug( + 'Set default n_episode mode(n_episode({}), env_num({}), traj_len({}))'.format( + self._default_n_episode, self._env_num, self._traj_len + ) + ) + for p in self._policy: + p.reset() + + def reset(self, _policy: Optional[List[namedtuple]] = None, _env: Optional[BaseEnvManager] = None) -> None: + """ + Overview: + Reset the environment and policy. + If _env is None, reset the old environment. + If _env is not None, replace the old environment in the collector with the new passed \ + in environment and launch. + If _policy is None, reset the old policy. + If _policy is not None, replace the old policy in the collector with the new passed in policy. + Arguments: + - policy (:obj:`Optional[List[namedtuple]]`): the api namedtuple of collect_mode policy + - env (:obj:`Optional[BaseEnvManager]`): instance of the subclass of vectorized \ + env_manager(BaseEnvManager) + """ + if _env is not None: + self.reset_env(_env) + if _policy is not None: + self.reset_policy(_policy) + + self._obs_pool = CachePool('obs', self._env_num, deepcopy=self._deepcopy_obs) + self._policy_output_pool = CachePool('policy_output', self._env_num) + # _traj_buffer is {env_id: {policy_id: TrajBuffer}}, is used to store traj_len pieces of transitions + self._traj_buffer = { + env_id: {policy_id: TrajBuffer(maxlen=self._traj_len) + for policy_id in range(2)} + for env_id in range(self._env_num) + } + self._env_info = {env_id: {'time': 0., 'step': 0} for env_id in range(self._env_num)} + + self._episode_info = [] + self._total_envstep_count = 0 + self._total_episode_count = 0 + self._total_duration = 0 + self._last_train_iter = 0 + self._end_flag = False + + def _reset_stat(self, env_id: int) -> None: + """ + Overview: + Reset the collector's state. Including reset the traj_buffer, obs_pool, policy_output_pool\ + and env_info. Reset these states according to env_id. You can refer to base_serial_collector\ + to get more messages. + Arguments: + - env_id (:obj:`int`): the id where we need to reset the collector's state + """ + for i in range(2): + self._traj_buffer[env_id][i].clear() + self._obs_pool.reset(env_id) + self._policy_output_pool.reset(env_id) + self._env_info[env_id] = {'time': 0., 'step': 0} + + @property + def envstep(self) -> int: + """ + Overview: + Print the total envstep count. + Return: + - envstep (:obj:`int`): the total envstep count + """ + return self._total_envstep_count + + def close(self) -> None: + """ + Overview: + Close the collector. If end_flag is False, close the environment, flush the tb_logger\ + and close the tb_logger. + """ + if self._end_flag: + return + self._end_flag = True + self._env.close() + self._tb_logger.flush() + self._tb_logger.close() + + def __del__(self) -> None: + """ + Overview: + Execute the close command and close the collector. __del__ is automatically called to \ + destroy the collector instance when the collector finishes its work + """ + self.close() + + def collect(self, + n_episode: Optional[int] = None, + train_iter: int = 0, + policy_kwargs: Optional[dict] = None) -> Tuple[List[Any], List[Any]]: + """ + Overview: + Collect `n_episode` data with policy_kwargs, which is already trained `train_iter` iterations + Arguments: + - n_episode (:obj:`int`): the number of collecting data episode + - train_iter (:obj:`int`): the number of training iteration + - policy_kwargs (:obj:`dict`): the keyword args for policy forward + Returns: + - return_data (:obj:`Tuple[List, List]`): A tuple with training sample(data) and episode info, \ + the former is a list containing collected episodes if not get_train_sample, \ + otherwise, return train_samples split by unroll_len. + """ + if n_episode is None: + if self._default_n_episode is None: + raise RuntimeError("Please specify collect n_episode") + else: + n_episode = self._default_n_episode + assert n_episode >= self._env_num, "Please make sure n_episode >= env_num" + if policy_kwargs is None: + policy_kwargs = {} + # temperature = policy_kwargs['temperature'] + # TODO(pu) + temperature = 1. + + collected_episode = 0 + return_data = [[] for _ in range(2)] + return_info = [[] for _ in range(2)] + ready_env_id = set() + remain_episode = n_episode + + while True: + + # for policy_id, policy in enumerate(self._policy): + + with self._timer: + # Get current env obs. + obs = self._env.ready_obs + new_available_env_id = set(obs.keys()).difference(ready_env_id) + ready_env_id = ready_env_id.union(set(list(new_available_env_id)[:remain_episode])) + remain_episode -= min(len(new_available_env_id), remain_episode) + + obs_ = {env_id: obs[env_id] for env_id in ready_env_id} + # Policy forward. + self._obs_pool.update(obs_) + simulation_envs = {} + for env_id in ready_env_id: + # create the new simulation env instances from the current collect env using the same env_config. + simulation_envs[env_id] = self._env._env_fn[env_id]() + + # ============================================================== + # policy forward + # ============================================================== + # policy_output = policy.forward(simulation_envs, obs_, temperature) + + obs_player_1 = {} + obs_player_2 = {} + simulation_envs_player_1 = {} + simulation_envs_player_2 = {} + ready_env_id_player_1 = [] + ready_env_id_player_2 = [] + for k, v in obs_.items(): + if v['to_play'] == 1: + obs_player_1[k] = v + simulation_envs_player_1[k] = simulation_envs[k] + ready_env_id_player_1.append(k) + elif v['to_play'] == 2: + obs_player_2[k] = v + simulation_envs_player_2[k] = simulation_envs[k] + ready_env_id_player_2.append(k) + + if len(ready_env_id_player_1) > 0: + policy_output_player_1 = self._policy[0].forward(simulation_envs_player_1, obs_player_1, temperature) + else: + policy_output_player_1 = {} + if len(ready_env_id_player_2) > 0: + policy_output_player_2 = self._policy[1].forward(simulation_envs_player_2, obs_player_2, temperature) + else: + policy_output_player_2 = {} + + policy_output = {} + policy_output.update(policy_output_player_1) + policy_output.update(policy_output_player_2) + + self._policy_output_pool.update(policy_output) + # Interact with env. + actions = {env_id: output['action'] for env_id, output in policy_output.items()} + actions = to_ndarray(actions) + + # ============================================================== + # Interact with env. + # ============================================================== + timesteps = self._env.step(actions) + + try: + interaction_duration = self._timer.value / len(timesteps) + except ZeroDivisionError: + interaction_duration = 0. + + for env_id, timestep in timesteps.items(): + self._env_info[env_id]['step'] += 1 + self._total_envstep_count += 1 + if env_id in ready_env_id_player_1: + policy_id = 0 + elif env_id in ready_env_id_player_2: + policy_id = 1 + with self._timer: + # for policy_id, policy in enumerate(self._policy): + # policy_timestep_data = [d[policy_id] if not isinstance(d, bool) else d for d in timestep] + # policy_timestep = type(timestep)(*policy_timestep_data) + # transition = self._policy[policy_id].process_transition( + # self._obs_pool[env_id][policy_id], self._policy_output_pool[env_id][policy_id], + # policy_timestep + # ) + transition = self._policy[policy_id].process_transition( + self._obs_pool[env_id], self._policy_output_pool[env_id], + timestep + ) + transition['collect_iter'] = train_iter + self._traj_buffer[env_id][policy_id].append(transition) + # prepare data + if timestep.done: + transitions = to_tensor_transitions( + self._traj_buffer[env_id][policy_id], not self._deepcopy_obs + ) + # reward_shaping + transitions = self.reward_shaping(transitions, timestep.info['eval_episode_return']) + + return_data[policy_id].append(transitions) + self._traj_buffer[env_id][policy_id].clear() + + self._env_info[env_id]['time'] += self._timer.value + interaction_duration + + # If env is done, record episode info and reset + if timestep.done: + self._total_episode_count += 1 + # the eval_episode_return is calculated from Player 1's perspective + reward = timestep.info['eval_episode_return'] + info = { + 'reward': reward, # only means player1 reward + 'time': self._env_info[env_id]['time'], + 'step': self._env_info[env_id]['step'], + } + collected_episode += 1 + self._episode_info.append(info) + for i, p in enumerate(self._policy): + p.reset([env_id]) + self._reset_stat(env_id) + ready_env_id.remove(env_id) + for policy_id in range(2): + # return_info[policy_id].append(timestep.info[policy_id]) + return_info[policy_id].append(timestep.info) + + # break the agent loop + # break + + if collected_episode >= n_episode: + break + # log + self._output_log(train_iter) + return return_data, return_info + + def _output_log(self, train_iter: int) -> None: + """ + Overview: + Print the output log information. You can refer to Docs/Best Practice/How to understand\ + training generated folders/Serial mode/log/collector for more details. + Arguments: + - train_iter (:obj:`int`): the number of training iteration. + """ + if (train_iter - self._last_train_iter) >= self._collect_print_freq and len(self._episode_info) > 0: + self._last_train_iter = train_iter + episode_count = len(self._episode_info) + envstep_count = sum([d['step'] for d in self._episode_info]) + duration = sum([d['time'] for d in self._episode_info]) + # episode_return0 = [d['reward0'] for d in self._episode_info] + # episode_return1 = [d['reward1'] for d in self._episode_info] + episode_reward = [d['reward'] for d in self._episode_info] + + self._total_duration += duration + info = { + 'episode_count': episode_count, + 'envstep_count': envstep_count, + 'avg_envstep_per_episode': envstep_count / episode_count, + 'avg_envstep_per_sec': envstep_count / duration, + 'avg_episode_per_sec': episode_count / duration, + 'collect_time': duration, + + # 'reward0_mean': np.mean(episode_return0), + # 'reward0_std': np.std(episode_return0), + # 'reward0_max': np.max(episode_return0), + # 'reward0_min': np.min(episode_return0), + # 'reward1_mean': np.mean(episode_return1), + # 'reward1_std': np.std(episode_return1), + # 'reward1_max': np.max(episode_return1), + # 'reward1_min': np.min(episode_return1), + + 'reward_mean': np.mean(episode_reward), + 'reward_std': np.std(episode_reward), + 'reward_max': np.max(episode_reward), + 'reward_min': np.min(episode_reward), + 'total_envstep_count': self._total_envstep_count, + 'total_episode_count': self._total_episode_count, + 'total_duration': self._total_duration, + } + self._episode_info.clear() + self._logger.info("collect end:\n{}".format('\n'.join(['{}: {}'.format(k, v) for k, v in info.items()]))) + for k, v in info.items(): + self._tb_logger.add_scalar('{}_iter/'.format(self._instance_name) + k, v, train_iter) + if k in ['total_envstep_count']: + continue + self._tb_logger.add_scalar('{}_step/'.format(self._instance_name) + k, v, self._total_envstep_count) + + def reward_shaping(self, transitions, eval_episode_return): + """ + Overview: + Shape the reward according to the player. + Return: + - transitions: data transitions. + """ + reward = transitions[-1]['reward'] + to_play = transitions[-1]['obs']['to_play'] + for t in transitions: + if t['obs']['to_play'] == -1: + # play_with_bot_mode + # the eval_episode_return is calculated from Player 1's perspective + t['reward'] = eval_episode_return + else: + # self_play_mode + if t['obs']['to_play'] == to_play: + t['reward'] = int(reward) + else: + t['reward'] = int(-reward) + return transitions \ No newline at end of file diff --git a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py new file mode 100644 index 000000000..d41739d79 --- /dev/null +++ b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py @@ -0,0 +1,136 @@ +from easydict import EasyDict + +# ============================================================== +# begin of the most frequently changed config specified by the user +# ============================================================== +board_size = 6 # default_size is 15 +prob_random_action_in_bot = 0.5 + +collector_env_num = 32 +n_episode = 32 +evaluator_env_num = 5 +num_simulations = 50 +update_per_collect = 50 +batch_size = 256 +max_env_step = int(1e6) + +# collector_env_num = 2 +# n_episode = 2 +# evaluator_env_num = 2 +# num_simulations = 2 +# update_per_collect = 5 +# batch_size = 2 +# max_env_step = int(2e5) +# ============================================================== +# end of the most frequently changed config specified by the user +# ============================================================== + +gomoku_alphazero_league_config = dict( + exp_name="gomoku_alphazero_league_seed0", + env=dict( + env_name="Gomoku", + board_size=board_size, + battle_mode='self_play_mode', + mcts_mode='self_play_mode', # only used in AlphaZero + channel_last=False, + scale=True, + agent_vs_human=False, + bot_action_type='v0', # {'v0', 'alpha_beta_pruning'} + prob_random_action_in_bot=prob_random_action_in_bot, + check_action_to_connect4_in_bot_v0=False, + stop_value=1, + collector_env_num=collector_env_num, + evaluator_env_num=evaluator_env_num, + n_evaluator_episode=evaluator_env_num, + manager=dict(shared_memory=False, ), + prob_random_agent=0, + prob_expert_agent=0, + ), + policy=dict( + model=dict( + observation_shape=(3, board_size, board_size), + action_space_size=int(1 * board_size * board_size), + num_res_blocks=1, + num_channels=32, + ), + cuda=True, + board_size=board_size, + update_per_collect=update_per_collect, + batch_size=batch_size, + optim_type='Adam', + lr_piecewise_constant_decay=False, + learning_rate=0.003, + grad_clip_value=0.5, + value_weight=1.0, + entropy_weight=0.0, + n_episode=n_episode, + eval_freq=int(2e3), + # eval_freq=int(100), # debug + mcts=dict(num_simulations=num_simulations), + collector_env_num=collector_env_num, + evaluator_env_num=evaluator_env_num, + league=dict( + log_freq=50, + # log_freq=2, # debug + player_category=['gomoku'], + # path to save policy of league player, user can specify this field + path_policy="gomoku_alphazero_league_policy_ckpt", + active_players=dict(main_player=1, ), + main_player=dict( + # An active player will be considered trained enough for snapshot after two phase steps. + one_phase_step=20000, + # A namedtuple of probabilities of selecting different opponent branch. + branch_probs=dict(pfsp=0.2, sp=0.8), + # If win rates between this player and all the opponents are greater than this value, this player can + # be regarded as strong enough to these opponents. If also already trained for one phase step, + # this player can be regarded as trained enough for snapshot. + strong_win_rate=0.7, + ), + use_pretrain=False, + use_pretrain_init_historical=False, + payoff=dict( + type='battle', + decay=0.99, + min_win_rate_games=4, + ), + metric=dict( + mu=0, + sigma=25 / 3, + beta=25 / 3 / 2, + tau=0.0, + draw_probability=0.02, + ), + ), + ), +) + +gomoku_alphazero_league_config = EasyDict(gomoku_alphazero_league_config) +main_config = gomoku_alphazero_league_config + +gomoku_alphazero_league_create_config = dict( + env=dict( + type='gomoku', + import_names=['zoo.board_games.gomoku.envs.gomoku_env'], + ), + env_manager=dict(type='subprocess'), + policy=dict( + type='alphazero', + import_names=['lzero.policy.alphazero'], + ), + collector=dict( + type='episode_alphazero', + get_train_sample=False, + import_names=['lzero.worker.alphazero_collector'], + ), + evaluator=dict( + type='alphazero', + import_names=['lzero.worker.alphazero_evaluator'], + ) +) +gomoku_alphazero_league_create_config = EasyDict(gomoku_alphazero_league_create_config) +create_config = gomoku_alphazero_league_create_config + +if __name__ == "__main__": + from lzero.entry import train_alphazero_league + from zoo.board_games.gomoku.envs.gomoku_env import GomokuEnv + train_alphazero_league(main_config, GomokuEnv) \ No newline at end of file diff --git a/zoo/board_games/gomoku/envs/gomoku_env.py b/zoo/board_games/gomoku/envs/gomoku_env.py index 620e226d9..41bcce49f 100644 --- a/zoo/board_games/gomoku/envs/gomoku_env.py +++ b/zoo/board_games/gomoku/envs/gomoku_env.py @@ -118,7 +118,9 @@ def step(self, action): if np.random.rand() < self.prob_random_agent: action = self.random_action() timestep = self._player_step(action) - # print(self.board) + # TODO(pu): check + # the eval_episode_return is calculated from Player 1's perspective + timestep.info['eval_episode_return'] = timestep.reward if timestep.obs['to_play'] == 1 else -timestep.reward return timestep elif self.battle_mode == 'play_with_bot_mode': # player 1 battle with expert player 2 diff --git a/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py b/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py new file mode 100644 index 000000000..ff45bc556 --- /dev/null +++ b/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py @@ -0,0 +1,134 @@ +from easydict import EasyDict + +# ============================================================== +# begin of the most frequently changed config specified by the user +# ============================================================== +# collector_env_num = 8 +# n_episode = 8 +# evaluator_env_num = 5 +# num_simulations = 25 +# update_per_collect = 50 +# batch_size = 256 +# max_env_step = int(2e5) + +collector_env_num = 2 +n_episode = 2 +evaluator_env_num = 2 +num_simulations = 2 +update_per_collect = 5 +batch_size = 2 +max_env_step = int(2e5) +# ============================================================== +# end of the most frequently changed config specified by the user +# ============================================================== + +tictactoe_alphazero_league_config = dict( + exp_name="tictactoe_alphazero_league_seed0", + env=dict( + board_size=3, + battle_mode='self_play_mode', + channel_last=False, # NOTE + collector_env_num=collector_env_num, + evaluator_env_num=evaluator_env_num, + n_evaluator_episode=evaluator_env_num, + manager=dict(shared_memory=False, ), + env_name="TicTacToe", + mcts_mode='self_play_mode', # only used in AlphaZero + bot_action_type='v0', # {'v0', 'alpha_beta_pruning'} + agent_vs_human=False, + prob_random_agent=0, + prob_expert_agent=0, + scale=True, + stop_value=2, + ), + policy=dict( + model=dict( + observation_shape=(3, 3, 3), + action_space_size=int(1 * 3 * 3), + # We use the small size model for tictactoe. + num_res_blocks=1, + num_channels=16, + fc_value_layers=[8], + fc_policy_layers=[8], + ), + cuda=True, + board_size=3, + update_per_collect=update_per_collect, + batch_size=batch_size, + optim_type='Adam', + lr_piecewise_constant_decay=False, + learning_rate=0.003, + grad_clip_value=0.5, + value_weight=1.0, + entropy_weight=0.0, + n_episode=n_episode, + eval_freq=int(2e3), + # eval_freq=int(100), # debug + mcts=dict(num_simulations=num_simulations), + collector_env_num=collector_env_num, + evaluator_env_num=evaluator_env_num, + league=dict( + log_freq=50, + # log_freq=2, # debug + player_category=['tictactoe'], + # path to save policy of league player, user can specify this field + path_policy="tictactoe_alphazero_league_policy_ckpt", + active_players=dict(main_player=1, ), + main_player=dict( + # An active player will be considered trained enough for snapshot after two phase steps. + one_phase_step=20000, + # A namedtuple of probabilities of selecting different opponent branch. + branch_probs=dict(pfsp=0.2, sp=0.8), + # If win rates between this player and all the opponents are greater than + # this value, this player can be regarded as strong enough to these opponents. + # If also already trained for one phase step, this player can be regarded as trained enough for snapshot. + strong_win_rate=0.7, + ), + use_pretrain=False, + use_pretrain_init_historical=False, + payoff=dict( + type='battle', + decay=0.99, + min_win_rate_games=4, + ), + metric=dict( + mu=0, + sigma=25 / 3, + beta=25 / 3 / 2, + tau=0.0, + draw_probability=0.02, + ), + ), + ), +) + +tictactoe_alphazero_league_config = EasyDict(tictactoe_alphazero_league_config) +main_config = tictactoe_alphazero_league_config + +tictactoe_alphazero_league_create_config = dict( + env=dict( + type='tictactoe', + import_names=['zoo.board_games.tictactoe.envs.tictactoe_env'], + ), + env_manager=dict(type='subprocess'), + policy=dict( + type='alphazero', + import_names=['lzero.policy.alphazero'], + ), + collector=dict( + type='episode_alphazero', + get_train_sample=False, + import_names=['lzero.worker.alphazero_collector'], + ), + evaluator=dict( + type='alphazero', + import_names=['lzero.worker.alphazero_evaluator'], + ) +) +tictactoe_alphazero_league_create_config = EasyDict(tictactoe_alphazero_league_create_config) +create_config = tictactoe_alphazero_league_create_config + +if __name__ == "__main__": + from lzero.entry import train_alphazero_league + from zoo.board_games.tictactoe.envs.tictactoe_env import TicTacToeEnv + train_alphazero_league(main_config, TicTacToeEnv) \ No newline at end of file diff --git a/zoo/board_games/tictactoe/envs/tictactoe_env.py b/zoo/board_games/tictactoe/envs/tictactoe_env.py index 230612884..dd4ede9c4 100644 --- a/zoo/board_games/tictactoe/envs/tictactoe_env.py +++ b/zoo/board_games/tictactoe/envs/tictactoe_env.py @@ -125,7 +125,9 @@ def step(self, action): action = self.bot_action() timestep = self._player_step(action) - # print(self.board) + # TODO(pu): check + # the eval_episode_return is calculated from Player 1's perspective + timestep.info['eval_episode_return'] = timestep.reward if timestep.obs['to_play'] == 1 else -timestep.reward return timestep elif self.battle_mode == 'play_with_bot_mode': # player 1 battle with expert player 2 From 473cfd62e8476d39562996e291a3311c98cb5db5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Thu, 4 May 2023 02:47:17 +0800 Subject: [PATCH 02/34] sync code --- .gitignore | 1 + .../config/gomoku_alphazero_league_config.py | 8 +++-- .../tictactoe_alphazero_league_config.py | 36 ++++++++++--------- 3 files changed, 25 insertions(+), 20 deletions(-) diff --git a/.gitignore b/.gitignore index c219b7fe4..ce59d57b9 100644 --- a/.gitignore +++ b/.gitignore @@ -1432,6 +1432,7 @@ collect_demo_data_config.py events.* /test_* # LightZero special key +/zoo/board_games/**/*.c /lzero/mcts/**/*.cpp /lzero/mcts/**/*.so /lzero/mcts/**/*.h diff --git a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py index d41739d79..83fc14771 100644 --- a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py +++ b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py @@ -13,6 +13,7 @@ update_per_collect = 50 batch_size = 256 max_env_step = int(1e6) +sp_prob = 0.8 # collector_env_num = 2 # n_episode = 2 @@ -26,7 +27,7 @@ # ============================================================== gomoku_alphazero_league_config = dict( - exp_name="gomoku_alphazero_league_seed0", + exp_name=f"gomoku_alphazero_league_sp-{sp_prob}_seed0", env=dict( env_name="Gomoku", board_size=board_size, @@ -74,13 +75,14 @@ # log_freq=2, # debug player_category=['gomoku'], # path to save policy of league player, user can specify this field - path_policy="gomoku_alphazero_league_policy_ckpt", + path_policy=f"gomoku_alphazero_league_policy_ckpt_sp-{sp_prob}", active_players=dict(main_player=1, ), main_player=dict( # An active player will be considered trained enough for snapshot after two phase steps. one_phase_step=20000, # A namedtuple of probabilities of selecting different opponent branch. - branch_probs=dict(pfsp=0.2, sp=0.8), + # branch_probs=dict(pfsp=0.2, sp=0.8), + branch_probs=dict(pfsp=1 - sp_prob, sp=sp_prob), # If win rates between this player and all the opponents are greater than this value, this player can # be regarded as strong enough to these opponents. If also already trained for one phase step, # this player can be regarded as trained enough for snapshot. diff --git a/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py b/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py index ff45bc556..0a171f134 100644 --- a/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py +++ b/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py @@ -3,27 +3,28 @@ # ============================================================== # begin of the most frequently changed config specified by the user # ============================================================== -# collector_env_num = 8 -# n_episode = 8 -# evaluator_env_num = 5 -# num_simulations = 25 -# update_per_collect = 50 -# batch_size = 256 -# max_env_step = int(2e5) - -collector_env_num = 2 -n_episode = 2 -evaluator_env_num = 2 -num_simulations = 2 -update_per_collect = 5 -batch_size = 2 +collector_env_num = 8 +n_episode = 8 +evaluator_env_num = 5 +num_simulations = 25 +update_per_collect = 50 +batch_size = 256 max_env_step = int(2e5) +sp_prob = 0.8 + +# collector_env_num = 2 +# n_episode = 2 +# evaluator_env_num = 2 +# num_simulations = 2 +# update_per_collect = 5 +# batch_size = 2 +# max_env_step = int(2e5) # ============================================================== # end of the most frequently changed config specified by the user # ============================================================== tictactoe_alphazero_league_config = dict( - exp_name="tictactoe_alphazero_league_seed0", + exp_name=f"tictactoe_alphazero_league_sp-{sp_prob}_seed0", env=dict( board_size=3, battle_mode='self_play_mode', @@ -72,13 +73,14 @@ # log_freq=2, # debug player_category=['tictactoe'], # path to save policy of league player, user can specify this field - path_policy="tictactoe_alphazero_league_policy_ckpt", + path_policy=f"tictactoe_alphazero_league_policy_ckpt_sp-{sp_prob}", active_players=dict(main_player=1, ), main_player=dict( # An active player will be considered trained enough for snapshot after two phase steps. one_phase_step=20000, # A namedtuple of probabilities of selecting different opponent branch. - branch_probs=dict(pfsp=0.2, sp=0.8), + # branch_probs=dict(pfsp=0.2, sp=0.8), + branch_probs=dict(pfsp=1-sp_prob, sp=sp_prob), # If win rates between this player and all the opponents are greater than # this value, this player can be regarded as strong enough to these opponents. # If also already trained for one phase step, this player can be regarded as trained enough for snapshot. From 7355fc8a8c109afe0ddf76c9fc81fff9d26066ad Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Thu, 4 May 2023 15:56:53 +0800 Subject: [PATCH 03/34] fix(pu): fix eval_episode_return in self_play_mode --- lzero/worker/battle_alphazero_collector.py | 4 +--- .../gomoku/config/gomoku_alphazero_league_config.py | 4 ++-- zoo/board_games/gomoku/envs/gomoku_env.py | 7 ++++--- .../tictactoe/config/tictactoe_alphazero_league_config.py | 6 +++--- zoo/board_games/tictactoe/envs/tictactoe_env.py | 7 ++++--- 5 files changed, 14 insertions(+), 14 deletions(-) diff --git a/lzero/worker/battle_alphazero_collector.py b/lzero/worker/battle_alphazero_collector.py index ee8002b16..fc8b20962 100644 --- a/lzero/worker/battle_alphazero_collector.py +++ b/lzero/worker/battle_alphazero_collector.py @@ -222,9 +222,7 @@ def collect(self, remain_episode = n_episode while True: - # for policy_id, policy in enumerate(self._policy): - with self._timer: # Get current env obs. obs = self._env.ready_obs @@ -329,7 +327,7 @@ def collect(self, # the eval_episode_return is calculated from Player 1's perspective reward = timestep.info['eval_episode_return'] info = { - 'reward': reward, # only means player1 reward + 'reward': reward, 'time': self._env_info[env_id]['time'], 'step': self._env_info[env_id]['step'], } diff --git a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py index 83fc14771..9a8848932 100644 --- a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py +++ b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py @@ -13,7 +13,7 @@ update_per_collect = 50 batch_size = 256 max_env_step = int(1e6) -sp_prob = 0.8 +sp_prob = 1 # TODO(pu): 0.8 # collector_env_num = 2 # n_episode = 2 @@ -27,7 +27,7 @@ # ============================================================== gomoku_alphazero_league_config = dict( - exp_name=f"gomoku_alphazero_league_sp-{sp_prob}_seed0", + exp_name=f"data_az_ptree_league/gomoku_alphazero_league_sp-{sp_prob}_seed0", env=dict( env_name="Gomoku", board_size=board_size, diff --git a/zoo/board_games/gomoku/envs/gomoku_env.py b/zoo/board_games/gomoku/envs/gomoku_env.py index 41bcce49f..ae6e22c36 100644 --- a/zoo/board_games/gomoku/envs/gomoku_env.py +++ b/zoo/board_games/gomoku/envs/gomoku_env.py @@ -118,9 +118,10 @@ def step(self, action): if np.random.rand() < self.prob_random_agent: action = self.random_action() timestep = self._player_step(action) - # TODO(pu): check - # the eval_episode_return is calculated from Player 1's perspective - timestep.info['eval_episode_return'] = timestep.reward if timestep.obs['to_play'] == 1 else -timestep.reward + if timestep.done: + # TODO(pu): check + # the eval_episode_return is calculated from Player 1's perspective + timestep.info['eval_episode_return'] = -timestep.reward if timestep.obs['to_play'] == 1 else timestep.reward return timestep elif self.battle_mode == 'play_with_bot_mode': # player 1 battle with expert player 2 diff --git a/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py b/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py index 0a171f134..7fff78ce4 100644 --- a/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py +++ b/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py @@ -10,7 +10,7 @@ update_per_collect = 50 batch_size = 256 max_env_step = int(2e5) -sp_prob = 0.8 +sp_prob = 1 # collector_env_num = 2 # n_episode = 2 @@ -24,7 +24,7 @@ # ============================================================== tictactoe_alphazero_league_config = dict( - exp_name=f"tictactoe_alphazero_league_sp-{sp_prob}_seed0", + exp_name=f"data_az_ptree_league/tictactoe_alphazero_league_sp-{sp_prob}_seed0", env=dict( board_size=3, battle_mode='self_play_mode', @@ -133,4 +133,4 @@ if __name__ == "__main__": from lzero.entry import train_alphazero_league from zoo.board_games.tictactoe.envs.tictactoe_env import TicTacToeEnv - train_alphazero_league(main_config, TicTacToeEnv) \ No newline at end of file + train_alphazero_league(main_config, TicTacToeEnv) diff --git a/zoo/board_games/tictactoe/envs/tictactoe_env.py b/zoo/board_games/tictactoe/envs/tictactoe_env.py index dd4ede9c4..47ff07515 100644 --- a/zoo/board_games/tictactoe/envs/tictactoe_env.py +++ b/zoo/board_games/tictactoe/envs/tictactoe_env.py @@ -125,9 +125,10 @@ def step(self, action): action = self.bot_action() timestep = self._player_step(action) - # TODO(pu): check - # the eval_episode_return is calculated from Player 1's perspective - timestep.info['eval_episode_return'] = timestep.reward if timestep.obs['to_play'] == 1 else -timestep.reward + if timestep.done: + # TODO(pu): check + # the eval_episode_return is calculated from Player 1's perspective + timestep.info['eval_episode_return'] = -timestep.reward if timestep.obs['to_play'] == 1 else timestep.reward return timestep elif self.battle_mode == 'play_with_bot_mode': # player 1 battle with expert player 2 From 9502336a559ab267fc6e2e9cee550678c9effac0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Thu, 11 May 2023 03:50:20 +0800 Subject: [PATCH 04/34] feature(pu): add rule_bot as the fist init historical_player in league --- lzero/entry/train_alphazero_league.py | 40 +- lzero/model/bot_model.py | 34 + lzero/worker/battle_alphazero_collector.py | 41 +- .../config/gomoku_alphazero_league_config.py | 5 +- .../gomoku/envs/get_done_winner_cython.cpp | 21769 ++++++++++++++++ .../gomoku/envs/legal_actions_cython.cpp | 21203 +++++++++++++++ zoo/board_games/gomoku/envs/rule_bot_v0.py | 315 + .../tictactoe_alphazero_league_config.py | 7 +- .../tictactoe/envs/get_done_winner_cython.cpp | 21717 +++++++++++++++ .../tictactoe/envs/legal_actions_cython.cpp | 21154 +++++++++++++++ zoo/board_games/tictactoe/envs/rule_bot_v0.py | 152 + 11 files changed, 86404 insertions(+), 33 deletions(-) create mode 100644 lzero/model/bot_model.py create mode 100644 zoo/board_games/gomoku/envs/get_done_winner_cython.cpp create mode 100644 zoo/board_games/gomoku/envs/legal_actions_cython.cpp create mode 100644 zoo/board_games/gomoku/envs/rule_bot_v0.py create mode 100644 zoo/board_games/tictactoe/envs/get_done_winner_cython.cpp create mode 100644 zoo/board_games/tictactoe/envs/legal_actions_cython.cpp create mode 100644 zoo/board_games/tictactoe/envs/rule_bot_v0.py diff --git a/lzero/entry/train_alphazero_league.py b/lzero/entry/train_alphazero_league.py index dd661d79b..26bc8d3fc 100644 --- a/lzero/entry/train_alphazero_league.py +++ b/lzero/entry/train_alphazero_league.py @@ -1,5 +1,4 @@ import copy -import copy import logging import os import shutil @@ -72,6 +71,7 @@ def _update_player(self, player: ActivePlayer, player_info: dict) -> None: assert isinstance(player, ActivePlayer) if 'learner_step' in player_info: player.total_agent_step = player_info['learner_step'] + # torch.save(player_info['state_dict'], player.checkpoint_path) # override @staticmethod @@ -138,6 +138,11 @@ def train_alphazero_league(cfg, Env, seed=0): policies['historical'] = policy + # create bot policy + cfg.policy.type = cfg.policy.league.player_category[0] + '_bot_v0' + bot_policy = create_policy(cfg.policy, enable_field=['learn', 'collect', 'eval']) + policies['bot'] = bot_policy + # create evaluator evaluator_env = SyncSubprocessEnvManager( env_fn=[partial(Env, evaluator_env_cfg) for _ in range(evaluator_env_num)], cfg=cfg.env.manager @@ -169,18 +174,18 @@ def load_checkpoint_fn(player_id: str, ckpt_path: str): set_pkg_seed(seed, use_cuda=cfg.policy.cuda) league_iter = 0 while True: - if evaluator.should_eval(main_learner.train_iter): - stop_flag, eval_episode_info = evaluator.eval( - main_learner.save_checkpoint, main_learner.train_iter, main_collector.envstep - ) - win_loss_result = win_loss_draw(eval_episode_info) - - # set eval bot rating as 100. - main_player.rating = league.metric_env.rate_1vsC( - main_player.rating, league.metric_env.create_rating(mu=100, sigma=1e-8), win_loss_result - ) - if stop_flag: - break + # if evaluator.should_eval(main_learner.train_iter): + # stop_flag, eval_episode_info = evaluator.eval( + # main_learner.save_checkpoint, main_learner.train_iter, main_collector.envstep + # ) + # win_loss_result = win_loss_draw(eval_episode_info) + # + # # set eval bot rating as 100. + # main_player.rating = league.metric_env.rate_1vsC( + # main_player.rating, league.metric_env.create_rating(mu=100, sigma=1e-8), win_loss_result + # ) + # if stop_flag: + # break for player_id, player_ckpt_path in zip(league.active_players_ids, league.active_players_ckpts): tb_logger.add_scalar( @@ -192,10 +197,12 @@ def load_checkpoint_fn(player_id: str, ckpt_path: str): job = league.get_job_info(player_id) opponent_player_id = job['player_id'][1] # print('job player: {}'.format(job['player_id'])) - if 'historical' in opponent_player_id: + if 'historical' in opponent_player_id and 'bot' not in opponent_player_id: opponent_policy = policies['historical'].collect_mode opponent_path = job['checkpoint_path'][1] opponent_policy.load_state_dict(torch.load(opponent_path, map_location='cpu')) + elif 'bot' in opponent_player_id: + opponent_policy = policies['bot'].collect_mode else: opponent_policy = policies[opponent_player_id].collect_mode @@ -223,6 +230,9 @@ def load_checkpoint_fn(player_id: str, ckpt_path: str): player_info = learner.learn_info player_info['player_id'] = player_id league.update_active_player(player_info) + + # player_info['state_dict'] = policies[player_id].learn_mode.state_dict() + league.judge_snapshot(player_id) # set eval_flag=True to enable trueskill update @@ -234,7 +244,7 @@ def load_checkpoint_fn(player_id: str, ckpt_path: str): 'player_id': job['player_id'], 'result': win_loss_result, } - league.finish_job(job_finish_info) + league.finish_job(job_finish_info, league_iter) if league_iter % cfg.policy.league.log_freq == 0: payoff_string = repr(league.payoff) diff --git a/lzero/model/bot_model.py b/lzero/model/bot_model.py new file mode 100644 index 000000000..bbacae280 --- /dev/null +++ b/lzero/model/bot_model.py @@ -0,0 +1,34 @@ +from typing import Optional, Tuple +import torch +import torch.nn as nn +from ding.utils import MODEL_REGISTRY, SequenceType + + +@MODEL_REGISTRY.register('bot_model') +class BotModel(nn.Module): + + def __init__( + self, + observation_shape: SequenceType = (12, 96, 96), + action_space_size: int = 6, + categorical_distribution: bool = False, + activation: Optional[nn.Module] = nn.ReLU(inplace=True), + representation_network: nn.Module = None, + last_linear_layer_init_zero: bool = True, + downsample: bool = False, + num_res_blocks: int = 1, + num_channels: int = 64, + value_head_channels: int = 16, + policy_head_channels: int = 16, + fc_value_layers: SequenceType = [32], + fc_policy_layers: SequenceType = [32], + value_support_size: int = 601, + ): + """ + Overview: + The fake model for bot, which is used to test the league. + """ + super(BotModel, self).__init__() + + def forward(self, state_batch: torch.Tensor) -> Tuple[torch.Tensor, torch.Tensor]: + pass diff --git a/lzero/worker/battle_alphazero_collector.py b/lzero/worker/battle_alphazero_collector.py index fc8b20962..7edd88e07 100644 --- a/lzero/worker/battle_alphazero_collector.py +++ b/lzero/worker/battle_alphazero_collector.py @@ -7,8 +7,10 @@ from ding.envs import BaseEnvManager from ding.utils import build_logger, EasyTimer, SERIAL_COLLECTOR_REGISTRY, dicts_to_lists from ding.torch_utils import to_tensor, to_ndarray -from ding.worker.collector.base_serial_collector import ISerialCollector, CachePool, TrajBuffer, INF, to_tensor_transitions - +from ding.worker.collector.base_serial_collector import ISerialCollector, CachePool, TrajBuffer, INF, \ + to_tensor_transitions +from zoo.board_games.tictactoe.envs.rule_bot_v0 import TictactoeBotV0 +from zoo.board_games.gomoku.envs.rule_bot_v0 import GomokuBotV0 @SERIAL_COLLECTOR_REGISTRY.register('episode_alphazero_battle') class BattleAlphaZeroCollector(ISerialCollector): @@ -260,11 +262,13 @@ def collect(self, ready_env_id_player_2.append(k) if len(ready_env_id_player_1) > 0: - policy_output_player_1 = self._policy[0].forward(simulation_envs_player_1, obs_player_1, temperature) + policy_output_player_1 = self._policy[0].forward(simulation_envs_player_1, obs_player_1, + temperature) else: policy_output_player_1 = {} if len(ready_env_id_player_2) > 0: - policy_output_player_2 = self._policy[1].forward(simulation_envs_player_2, obs_player_2, temperature) + policy_output_player_2 = self._policy[1].forward(simulation_envs_player_2, obs_player_2, + temperature) else: policy_output_player_2 = {} @@ -298,15 +302,24 @@ def collect(self, # for policy_id, policy in enumerate(self._policy): # policy_timestep_data = [d[policy_id] if not isinstance(d, bool) else d for d in timestep] # policy_timestep = type(timestep)(*policy_timestep_data) - # transition = self._policy[policy_id].process_transition( - # self._obs_pool[env_id][policy_id], self._policy_output_pool[env_id][policy_id], - # policy_timestep - # ) - transition = self._policy[policy_id].process_transition( - self._obs_pool[env_id], self._policy_output_pool[env_id], - timestep - ) - transition['collect_iter'] = train_iter + # transition = self._policy[policy_id].process_transition( + # self._obs_pool[env_id][policy_id], self._policy_output_pool[env_id][policy_id], + # policy_timestep + # ) + if isinstance(self._policy[policy_id].forward.__self__, TictactoeBotV0) or isinstance(self._policy[policy_id].forward.__self__, GomokuBotV0): + # bot policy does not need to process transition + transition = self._policy[0].process_transition( + self._obs_pool[env_id], self._policy_output_pool[env_id], + timestep + ) + transition['collect_iter'] = train_iter + else: + transition = self._policy[policy_id].process_transition( + self._obs_pool[env_id], self._policy_output_pool[env_id], + timestep + ) + transition['collect_iter'] = train_iter + self._traj_buffer[env_id][policy_id].append(transition) # prepare data if timestep.done: @@ -421,4 +434,4 @@ def reward_shaping(self, transitions, eval_episode_return): t['reward'] = int(reward) else: t['reward'] = int(-reward) - return transitions \ No newline at end of file + return transitions diff --git a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py index 9a8848932..405f38608 100644 --- a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py +++ b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py @@ -13,7 +13,7 @@ update_per_collect = 50 batch_size = 256 max_env_step = int(1e6) -sp_prob = 1 # TODO(pu): 0.8 +sp_prob = 0. # TODO(pu): 0, 0.8, 1 # collector_env_num = 2 # n_episode = 2 @@ -22,6 +22,7 @@ # update_per_collect = 5 # batch_size = 2 # max_env_step = int(2e5) +# sp_prob = 0.8 # ============================================================== # end of the most frequently changed config specified by the user # ============================================================== @@ -90,6 +91,8 @@ ), use_pretrain=False, use_pretrain_init_historical=False, + # "use_bot_init_historica" means whether to use bot as an init historical player + use_bot_init_historical=True, payoff=dict( type='battle', decay=0.99, diff --git a/zoo/board_games/gomoku/envs/get_done_winner_cython.cpp b/zoo/board_games/gomoku/envs/get_done_winner_cython.cpp new file mode 100644 index 000000000..178c63a6a --- /dev/null +++ b/zoo/board_games/gomoku/envs/get_done_winner_cython.cpp @@ -0,0 +1,21769 @@ +/* Generated by Cython 0.29.34 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [], + "include_dirs": [ + "/private/var/folders/r5/znmp_3cn0_b41yvr2tvld9ys0qypks/T/pip-build-env-6l8r0sjs/overlay/lib/python3.8/site-packages/numpy/core/include" + ], + "language": "c++", + "name": "zoo.board_games.gomoku.envs.get_done_winner_cython", + "sources": [ + "/Users/puyuan/code/LightZero/zoo/board_games/gomoku/envs/get_done_winner_cython.pyx" + ] + }, + "module_name": "zoo.board_games.gomoku.envs.get_done_winner_cython" +} +END: Cython Metadata */ + +#ifndef PY_SSIZE_T_CLEAN +#define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.6+ or Python 3.3+. +#else +#define CYTHON_ABI "0_29_34" +#define CYTHON_HEX_VERSION 0x001D22F0 +#define CYTHON_FUTURE_DIVISION 1 +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#define __PYX_COMMA , +#ifndef HAVE_LONG_LONG + #if PY_VERSION_HEX >= 0x02070000 + #define HAVE_LONG_LONG + #endif +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif +#elif defined(PY_NOGIL) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_NOGIL 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #ifndef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_NOGIL 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #define CYTHON_USE_PYLONG_INTERNALS (PY_VERSION_HEX < 0x030C00A5) + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #if PY_VERSION_HEX >= 0x030B00A4 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #elif !defined(CYTHON_FAST_THREAD_STATE) + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #endif + #ifndef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS ((PY_VERSION_HEX >= 0x030600B1) && (PY_VERSION_HEX < 0x030C00A5)) + #endif + #if PY_VERSION_HEX >= 0x030B00A4 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #elif !defined(CYTHON_USE_EXC_INFO_STACK) + #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #endif + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_MAJOR_VERSION < 3 + #include "longintrepr.h" + #endif + #undef SHIFT + #undef BASE + #undef MASK + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + #endif +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) +#ifdef _MSC_VER + #ifndef _MSC_STDINT_H_ + #if _MSC_VER < 1300 + typedef unsigned char uint8_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int32 uint32_t; + #endif + #endif +#else + #include +#endif +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) && __cplusplus >= 201103L + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #elif __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + #if defined(__clang__ ) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif + +#ifndef __cplusplus + #error "Cython files generated with the C++ option must be compiled with a C++ compiler." +#endif +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #else + #define CYTHON_INLINE inline + #endif +#endif +template +void __Pyx_call_destructor(T& x) { + x.~T(); +} +template +class __Pyx_FakeReference { + public: + __Pyx_FakeReference() : ptr(NULL) { } + __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { } + T *operator->() { return ptr; } + T *operator&() { return ptr; } + operator T&() { return *ptr; } + template bool operator ==(U other) { return *ptr == other; } + template bool operator !=(U other) { return *ptr != other; } + private: + T *ptr; +}; + +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_DefaultClassType PyType_Type +#if PY_VERSION_HEX >= 0x030B00A1 + static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; + PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; + const char *fn_cstr=NULL; + const char *name_cstr=NULL; + PyCodeObject* co=NULL; + PyObject *type, *value, *traceback; + PyErr_Fetch(&type, &value, &traceback); + if (!(kwds=PyDict_New())) goto end; + if (!(argcount=PyLong_FromLong(a))) goto end; + if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; + if (!(posonlyargcount=PyLong_FromLong(0))) goto end; + if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; + if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; + if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; + if (!(nlocals=PyLong_FromLong(l))) goto end; + if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; + if (!(stacksize=PyLong_FromLong(s))) goto end; + if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; + if (!(flags=PyLong_FromLong(f))) goto end; + if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; + if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; + if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; + if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; + if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; + if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here + if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; + Py_XDECREF((PyObject*)co); + co = (PyCodeObject*)call_result; + call_result = NULL; + if (0) { + cleanup_code_too: + Py_XDECREF((PyObject*)co); + co = NULL; + } + end: + Py_XDECREF(kwds); + Py_XDECREF(argcount); + Py_XDECREF(posonlyargcount); + Py_XDECREF(kwonlyargcount); + Py_XDECREF(nlocals); + Py_XDECREF(stacksize); + Py_XDECREF(replace); + Py_XDECREF(call_result); + Py_XDECREF(empty); + if (type) { + PyErr_Restore(type, value, traceback); + } + return co; + } +#else + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#endif + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef METH_STACKLESS + #define METH_STACKLESS 0 +#endif +#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) + #ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #define __Pyx_PyCFunctionFast _PyCFunctionFast + #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords +#endif +#if CYTHON_FAST_PYCCALL +#define __Pyx_PyFastCFunction_Check(func)\ + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +#else +#define __Pyx_PyFastCFunction_Check(func) 0 +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 + #define PyMem_RawMalloc(n) PyMem_Malloc(n) + #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) + #define PyMem_RawFree(p) PyMem_Free(p) +#endif +#if CYTHON_COMPILING_IN_PYSTON + #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x03060000 + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#elif PY_VERSION_HEX >= 0x03000000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_Current +#endif +#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) +#include "pythread.h" +#define Py_tss_NEEDS_INIT 0 +typedef int Py_tss_t; +static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { + *key = PyThread_create_key(); + return 0; +} +static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { + Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); + *key = Py_tss_NEEDS_INIT; + return key; +} +static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { + PyObject_Free(key); +} +static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { + return *key != Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { + PyThread_delete_key(*key); + *key = Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { + return PyThread_set_key_value(*key, value); +} +static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { + return PyThread_get_key_value(*key); +} +#endif +#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif +#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#else +#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #if 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_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 PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #else + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif + #endif +#else + #define CYTHON_PEP393_ENABLED 0 + #define PyUnicode_1BYTE_KIND 1 + #define PyUnicode_2BYTE_KIND 2 + #define PyUnicode_4BYTE_KIND 4 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#ifndef PyObject_Unicode + #define PyObject_Unicode PyObject_Str +#endif +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) +#else + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef __Pyx_PyAsyncMethodsStruct + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; +#endif + +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #if !defined(_USE_MATH_DEFINES) + #define _USE_MATH_DEFINES + #endif +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + +#define __PYX_MARK_ERR_POS(f_index, lineno) \ + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__zoo__board_games__gomoku__envs__get_done_winner_cython +#define __PYX_HAVE_API__zoo__board_games__gomoku__envs__get_done_winner_cython +/* Early includes */ +#include +#include "pythread.h" +#include +#include +#include +#include "pystate.h" +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { + return (size_t) i < (size_t) limit; +} +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) + #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +#define __Pyx_PySequence_Tuple(obj)\ + (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); +#if CYTHON_ASSUME_SAFE_MACROS +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } + +static PyObject *__pyx_m = NULL; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_cython_runtime = NULL; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + + +static const char *__pyx_f[] = { + "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx", + "stringsource", +}; +/* MemviewSliceStruct.proto */ +struct __pyx_memoryview_obj; +typedef struct { + struct __pyx_memoryview_obj *memview; + char *data; + Py_ssize_t shape[8]; + Py_ssize_t strides[8]; + Py_ssize_t suboffsets[8]; +} __Pyx_memviewslice; +#define __Pyx_MemoryView_Len(m) (m.shape[0]) + +/* Atomics.proto */ +#include +#ifndef CYTHON_ATOMICS + #define CYTHON_ATOMICS 1 +#endif +#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS +#define __pyx_atomic_int_type int +#if CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\ + (__GNUC_MINOR__ > 1 ||\ + (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) + #define __pyx_atomic_incr_aligned(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_decr_aligned(value) __sync_fetch_and_sub(value, 1) + #ifdef __PYX_DEBUG_ATOMICS + #warning "Using GNU atomics" + #endif +#elif CYTHON_ATOMICS && defined(_MSC_VER) && CYTHON_COMPILING_IN_NOGIL + #include + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type long + #pragma intrinsic (_InterlockedExchangeAdd) + #define __pyx_atomic_incr_aligned(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_decr_aligned(value) _InterlockedExchangeAdd(value, -1) + #ifdef __PYX_DEBUG_ATOMICS + #pragma message ("Using MSVC atomics") + #endif +#else + #undef CYTHON_ATOMICS + #define CYTHON_ATOMICS 0 + #ifdef __PYX_DEBUG_ATOMICS + #warning "Not using atomics" + #endif +#endif +typedef volatile __pyx_atomic_int_type __pyx_atomic_int; +#if CYTHON_ATOMICS + #define __pyx_add_acquisition_count(memview)\ + __pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview)) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview)) +#else + #define __pyx_add_acquisition_count(memview)\ + __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) +#endif + +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + +/* NoFastGil.proto */ +#define __Pyx_PyGILState_Ensure PyGILState_Ensure +#define __Pyx_PyGILState_Release PyGILState_Release +#define __Pyx_FastGIL_Remember() +#define __Pyx_FastGIL_Forget() +#define __Pyx_FastGilFuncInit() + +/* BufferFormatStructs.proto */ +#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; + +/* "View.MemoryView":106 + * + * @cname("__pyx_array") + * cdef class array: # <<<<<<<<<<<<<< + * + * cdef: + */ +struct __pyx_array_obj { + PyObject_HEAD + struct __pyx_vtabstruct_array *__pyx_vtab; + char *data; + Py_ssize_t len; + char *format; + int ndim; + Py_ssize_t *_shape; + Py_ssize_t *_strides; + Py_ssize_t itemsize; + PyObject *mode; + PyObject *_format; + void (*callback_free_data)(void *); + int free_data; + int dtype_is_object; +}; + + +/* "View.MemoryView":280 + * + * @cname('__pyx_MemviewEnum') + * cdef class Enum(object): # <<<<<<<<<<<<<< + * cdef object name + * def __init__(self, name): + */ +struct __pyx_MemviewEnum_obj { + PyObject_HEAD + PyObject *name; +}; + + +/* "View.MemoryView":331 + * + * @cname('__pyx_memoryview') + * cdef class memoryview(object): # <<<<<<<<<<<<<< + * + * cdef object obj + */ +struct __pyx_memoryview_obj { + PyObject_HEAD + struct __pyx_vtabstruct_memoryview *__pyx_vtab; + PyObject *obj; + PyObject *_size; + PyObject *_array_interface; + PyThread_type_lock lock; + __pyx_atomic_int acquisition_count[2]; + __pyx_atomic_int *acquisition_count_aligned_p; + Py_buffer view; + int flags; + int dtype_is_object; + __Pyx_TypeInfo *typeinfo; +}; + + +/* "View.MemoryView":967 + * + * @cname('__pyx_memoryviewslice') + * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< + * "Internal class for passing memoryview slices to Python" + * + */ +struct __pyx_memoryviewslice_obj { + struct __pyx_memoryview_obj __pyx_base; + __Pyx_memviewslice from_slice; + PyObject *from_object; + PyObject *(*to_object_func)(char *); + int (*to_dtype_func)(char *, PyObject *); +}; + + + +/* "View.MemoryView":106 + * + * @cname("__pyx_array") + * cdef class array: # <<<<<<<<<<<<<< + * + * cdef: + */ + +struct __pyx_vtabstruct_array { + PyObject *(*get_memview)(struct __pyx_array_obj *); +}; +static struct __pyx_vtabstruct_array *__pyx_vtabptr_array; + + +/* "View.MemoryView":331 + * + * @cname('__pyx_memoryview') + * cdef class memoryview(object): # <<<<<<<<<<<<<< + * + * cdef object obj + */ + +struct __pyx_vtabstruct_memoryview { + char *(*get_item_pointer)(struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*is_slice)(struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*setitem_slice_assignment)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); + PyObject *(*setitem_slice_assign_scalar)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*setitem_indexed)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); + PyObject *(*convert_item_to_object)(struct __pyx_memoryview_obj *, char *); + PyObject *(*assign_item_from_object)(struct __pyx_memoryview_obj *, char *, PyObject *); +}; +static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview; + + +/* "View.MemoryView":967 + * + * @cname('__pyx_memoryviewslice') + * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< + * "Internal class for passing memoryview slices to Python" + * + */ + +struct __pyx_vtabstruct__memoryviewslice { + struct __pyx_vtabstruct_memoryview __pyx_base; +}; +static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice; + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* 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); + +/* 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); + +/* 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); + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* PyCFunctionFastCall.proto */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#else +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); +#else +#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) +#endif +#define __Pyx_BUILD_ASSERT_EXPR(cond)\ + (sizeof(char [1 - 2*!(cond)]) - 1) +#ifndef Py_MEMBER_SIZE +#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) +#endif +#if CYTHON_FAST_PYCALL + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" +#if PY_VERSION_HEX >= 0x030b00a6 + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif + #define __Pxy_PyFrame_Initialize_Offsets()\ + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) + #define __Pyx_PyFrame_GetLocalsplus(frame)\ + (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#endif // CYTHON_FAST_PYCALL +#endif + +/* PyObjectCall2Args.proto */ +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* StrEquals.proto */ +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals +#else +#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals +#endif + +/* DivInt[Py_ssize_t].proto */ +static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t, Py_ssize_t); + +/* UnaryNegOverflows.proto */ +#define UNARY_NEG_WOULD_OVERFLOW(x)\ + (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x))) + +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *); /*proto*/ +/* GetAttr.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); + +/* 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) do {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ + (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ + __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ + PY_UINT64_T __pyx_dict_version;\ + PyObject *__pyx_dict_cached_value;\ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); +#else +#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) +#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); +#endif + +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/* RaiseNoneIterError.proto */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* GetTopmostException.proto */ +#if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); +#endif + +/* SaveResetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +#else +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/* GetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* SwapException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); +#else +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) +#endif +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) + +static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +/* ListCompAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len)) { + Py_INCREF(x); + PyList_SET_ITEM(list, len, x); + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) +#endif + +/* PyIntBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) +#endif + +/* ListExtend.proto */ +static CYTHON_INLINE int __Pyx_PyList_Extend(PyObject* L, PyObject* v) { +#if CYTHON_COMPILING_IN_CPYTHON + PyObject* none = _PyList_Extend((PyListObject*)L, v); + if (unlikely(!none)) + return -1; + Py_DECREF(none); + return 0; +#else + return PyList_SetSlice(L, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, v); +#endif +} + +/* ListAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { + Py_INCREF(x); + PyList_SET_ITEM(list, len, x); + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#endif + +/* DivInt[long].proto */ +static CYTHON_INLINE long __Pyx_div_long(long, long); + +/* PySequenceContains.proto */ +static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { + int result = PySequence_Contains(seq, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +/* ImportFrom.proto */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +/* HasAttr.proto */ +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); + +/* PyObject_GenericGetAttrNoDict.proto */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr +#endif + +/* PyObject_GenericGetAttr.proto */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr +#endif + +/* SetVTable.proto */ +static int __Pyx_SetVtable(PyObject *dict, void *vtable); + +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + +/* SetupReduce.proto */ +static int __Pyx_setup_reduce(PyObject* type_obj); + +/* CLineInTraceback.proto */ +#ifdef CYTHON_CLINE_IN_TRACEBACK +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#else +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#endif + +/* CodeObjectCache.proto */ +typedef struct { + PyCodeObject* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +#if PY_MAJOR_VERSION < 3 + static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); + static void __Pyx_ReleaseBuffer(Py_buffer *view); +#else + #define __Pyx_GetBuffer PyObject_GetBuffer + #define __Pyx_ReleaseBuffer PyBuffer_Release +#endif + + +/* BufferStructDeclare.proto */ +typedef struct { + Py_ssize_t shape, strides, suboffsets; +} __Pyx_Buf_DimInfo; +typedef struct { + size_t refcount; + Py_buffer pybuffer; +} __Pyx_Buffer; +typedef struct { + __Pyx_Buffer *rcbuffer; + char *data; + __Pyx_Buf_DimInfo diminfo[8]; +} __Pyx_LocalBuf_ND; + +/* MemviewSliceIsContig.proto */ +static int __pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim); + +/* OverlappingSlices.proto */ +static int __pyx_slices_overlap(__Pyx_memviewslice *slice1, + __Pyx_memviewslice *slice2, + int ndim, size_t itemsize); + +/* Capsule.proto */ +static CYTHON_INLINE PyObject *__pyx_capsule_create(void *p, const char *sig); + +/* GCCDiagnostics.proto */ +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + +/* 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_dsds_nn_int32_t(PyObject *, int writable_flag); + +/* MemviewSliceCopyTemplate.proto */ +static __Pyx_memviewslice +__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, + const char *mode, int ndim, + size_t sizeof_dtype, int contig_flag, + int dtype_is_object); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int32_t __Pyx_PyInt_As_int32_t(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int32_t(int32_t value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* 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 'libc.stdint' */ + +/* Module declarations from 'cython.view' */ + +/* Module declarations from 'cython' */ + +/* Module declarations from 'zoo.board_games.gomoku.envs.get_done_winner_cython' */ +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 PyObject *__pyx_f_3zoo_11board_games_6gomoku_4envs_22get_done_winner_cython_get_done_winner_cython(int32_t, __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_nn_int32_t = { "int32_t", NULL, sizeof(int32_t), { 0 }, 0, IS_UNSIGNED(int32_t) ? 'U' : 'I', IS_UNSIGNED(int32_t), 0 }; +#define __Pyx_MODULE_NAME "zoo.board_games.gomoku.envs.get_done_winner_cython" +extern int __pyx_module_is_main_zoo__board_games__gomoku__envs__get_done_winner_cython; +int __pyx_module_is_main_zoo__board_games__gomoku__envs__get_done_winner_cython = 0; + +/* Implementation of 'zoo.board_games.gomoku.envs.get_done_winner_cython' */ +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_test[] = "__test__"; +static const char __pyx_k_ASCII[] = "ASCII"; +static const char __pyx_k_board[] = "board"; +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_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_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_board_size[] = "board_size"; +static const char __pyx_k_pyx_result[] = "__pyx_result"; +static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static const char __pyx_k_MemoryError[] = "MemoryError"; +static const char __pyx_k_PickleError[] = "PickleError"; +static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; +static const char __pyx_k_stringsource[] = "stringsource"; +static const char __pyx_k_pyx_getbuffer[] = "__pyx_getbuffer"; +static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; +static const char __pyx_k_View_MemoryView[] = "View.MemoryView"; +static const char __pyx_k_allocate_buffer[] = "allocate_buffer"; +static const char __pyx_k_dtype_is_object[] = "dtype_is_object"; +static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; +static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; +static const char __pyx_k_pyx_unpickle_Enum[] = "__pyx_unpickle_Enum"; +static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_strided_and_direct[] = ""; +static const char __pyx_k_strided_and_indirect[] = ""; +static const char __pyx_k_contiguous_and_direct[] = ""; +static const char __pyx_k_MemoryView_of_r_object[] = ""; +static const char __pyx_k_MemoryView_of_r_at_0x_x[] = ""; +static const char __pyx_k_contiguous_and_indirect[] = ""; +static const char __pyx_k_Cannot_index_with_type_s[] = "Cannot index with type '%s'"; +static const char __pyx_k_Invalid_shape_in_axis_d_d[] = "Invalid shape in axis %d: %d."; +static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array"; +static const char __pyx_k_unable_to_allocate_array_data[] = "unable to allocate array data."; +static const char __pyx_k_strided_and_direct_or_indirect[] = ""; +static const char __pyx_k_Buffer_view_does_not_expose_stri[] = "Buffer view does not expose strides"; +static const char __pyx_k_Can_only_create_a_buffer_that_is[] = "Can only create a buffer that is contiguous in memory."; +static const char __pyx_k_Cannot_assign_to_read_only_memor[] = "Cannot assign to read-only memoryview"; +static const char __pyx_k_Cannot_create_writable_memory_vi[] = "Cannot create writable memory view from read-only memoryview"; +static const char __pyx_k_Empty_shape_tuple_for_cython_arr[] = "Empty shape tuple for cython.array"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))"; +static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported"; +static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got %s"; +static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis %d)"; +static const char __pyx_k_Unable_to_convert_item_to_object[] = "Unable to convert item to object"; +static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension %d (got %d and %d)"; +static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; +static const char __pyx_k_unable_to_allocate_shape_and_str[] = "unable to allocate shape and strides."; +static PyObject *__pyx_n_s_ASCII; +static PyObject *__pyx_kp_s_Buffer_view_does_not_expose_stri; +static PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is; +static PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor; +static PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi; +static PyObject *__pyx_kp_s_Cannot_index_with_type_s; +static PyObject *__pyx_n_s_Ellipsis; +static PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr; +static PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; +static PyObject *__pyx_n_s_IndexError; +static PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte; +static PyObject *__pyx_kp_s_Invalid_mode_expected_c_or_fortr; +static PyObject *__pyx_kp_s_Invalid_shape_in_axis_d_d; +static PyObject *__pyx_n_s_MemoryError; +static PyObject *__pyx_kp_s_MemoryView_of_r_at_0x_x; +static PyObject *__pyx_kp_s_MemoryView_of_r_object; +static PyObject *__pyx_n_b_O; +static PyObject *__pyx_kp_s_Out_of_bounds_on_buffer_access_a; +static PyObject *__pyx_n_s_PickleError; +static PyObject *__pyx_n_s_TypeError; +static PyObject *__pyx_kp_s_Unable_to_convert_item_to_object; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_View_MemoryView; +static PyObject *__pyx_n_s_allocate_buffer; +static PyObject *__pyx_n_s_base; +static PyObject *__pyx_n_s_board; +static PyObject *__pyx_n_s_board_size; +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_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_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_pf_3zoo_11board_games_6gomoku_4envs_22get_done_winner_cython_get_done_winner_cython(CYTHON_UNUSED PyObject *__pyx_self, int32_t __pyx_v_board_size, __Pyx_memviewslice __pyx_v_board); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr); /* proto */ +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ +static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object); /* proto */ +static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_1; +static PyObject *__pyx_int_112105877; +static PyObject *__pyx_int_136983863; +static PyObject *__pyx_int_184977713; +static PyObject *__pyx_int_neg_1; +static PyObject *__pyx_tuple_; +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__20; +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__16; +static PyObject *__pyx_tuple__17; +static PyObject *__pyx_tuple__18; +static PyObject *__pyx_tuple__19; +static PyObject *__pyx_tuple__21; +static PyObject *__pyx_tuple__22; +static PyObject *__pyx_tuple__23; +static PyObject *__pyx_tuple__24; +static PyObject *__pyx_tuple__25; +static PyObject *__pyx_tuple__26; +static PyObject *__pyx_tuple__27; +static PyObject *__pyx_tuple__28; +static PyObject *__pyx_tuple__29; +static PyObject *__pyx_tuple__30; +static PyObject *__pyx_codeobj__31; +/* Late includes */ + +/* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":6 + * @cython.boundscheck(False) + * @cython.wraparound(False) + * cpdef get_done_winner_cython(int32_t board_size, int32_t[:, :] board): # <<<<<<<<<<<<<< + * """ + * Overview: + */ + +static PyObject *__pyx_pw_3zoo_11board_games_6gomoku_4envs_22get_done_winner_cython_1get_done_winner_cython(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyObject *__pyx_f_3zoo_11board_games_6gomoku_4envs_22get_done_winner_cython_get_done_winner_cython(int32_t __pyx_v_board_size, __Pyx_memviewslice __pyx_v_board, CYTHON_UNUSED int __pyx_skip_dispatch) { + int32_t __pyx_v_i; + int32_t __pyx_v_j; + int32_t __pyx_v_player; + int32_t __pyx_v_x; + int32_t __pyx_v_y; + int32_t __pyx_v_count; + int __pyx_v_has_legal_actions; + PyObject *__pyx_v_directions = 0; + PyObject *__pyx_v_d = NULL; + CYTHON_UNUSED long __pyx_v__; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int32_t __pyx_t_1; + int32_t __pyx_t_2; + int32_t __pyx_t_3; + int32_t __pyx_t_4; + int32_t __pyx_t_5; + int32_t __pyx_t_6; + Py_ssize_t __pyx_t_7; + Py_ssize_t __pyx_t_8; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + Py_ssize_t __pyx_t_11; + PyObject *(*__pyx_t_12)(PyObject *); + PyObject *__pyx_t_13 = NULL; + int32_t __pyx_t_14; + int32_t __pyx_t_15; + long __pyx_t_16; + int __pyx_t_17; + PyObject *__pyx_t_18 = NULL; + PyObject *__pyx_t_19 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_done_winner_cython", 0); + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":21 + * """ + * cdef int32_t i, j, player, x, y, count + * cdef bint has_legal_actions = False # <<<<<<<<<<<<<< + * cdef directions = ((1, -1), (1, 0), (1, 1), (0, 1)) + * + */ + __pyx_v_has_legal_actions = 0; + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":22 + * cdef int32_t i, j, player, x, y, count + * cdef bint has_legal_actions = False + * cdef directions = ((1, -1), (1, 0), (1, 1), (0, 1)) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_INCREF(__pyx_tuple__5); + __pyx_v_directions = __pyx_tuple__5; + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":25 + * + * + * for i in range(board_size): # <<<<<<<<<<<<<< + * for j in range(board_size): + * if board[i, j] == 0: + */ + __pyx_t_1 = __pyx_v_board_size; + __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; + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":26 + * + * for i in range(board_size): + * for j in range(board_size): # <<<<<<<<<<<<<< + * if board[i, j] == 0: + * has_legal_actions = True + */ + __pyx_t_4 = __pyx_v_board_size; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_j = __pyx_t_6; + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":27 + * for i in range(board_size): + * for j in range(board_size): + * if board[i, j] == 0: # <<<<<<<<<<<<<< + * has_legal_actions = True + * continue + */ + __pyx_t_7 = __pyx_v_i; + __pyx_t_8 = __pyx_v_j; + __pyx_t_9 = (((*((int32_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_board.data + __pyx_t_7 * __pyx_v_board.strides[0]) ) + __pyx_t_8 * __pyx_v_board.strides[1]) ))) == 0) != 0); + if (__pyx_t_9) { + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":28 + * for j in range(board_size): + * if board[i, j] == 0: + * has_legal_actions = True # <<<<<<<<<<<<<< + * continue + * player = board[i, j] + */ + __pyx_v_has_legal_actions = 1; + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":29 + * if board[i, j] == 0: + * has_legal_actions = True + * continue # <<<<<<<<<<<<<< + * player = board[i, j] + * for d in directions: + */ + goto __pyx_L5_continue; + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":27 + * for i in range(board_size): + * for j in range(board_size): + * if board[i, j] == 0: # <<<<<<<<<<<<<< + * has_legal_actions = True + * continue + */ + } + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":30 + * has_legal_actions = True + * continue + * player = board[i, j] # <<<<<<<<<<<<<< + * for d in directions: + * x, y = i, j + */ + __pyx_t_8 = __pyx_v_i; + __pyx_t_7 = __pyx_v_j; + __pyx_v_player = (*((int32_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_board.data + __pyx_t_8 * __pyx_v_board.strides[0]) ) + __pyx_t_7 * __pyx_v_board.strides[1]) ))); + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":31 + * continue + * player = board[i, j] + * for d in directions: # <<<<<<<<<<<<<< + * x, y = i, j + * count = 0 + */ + if (likely(PyList_CheckExact(__pyx_v_directions)) || PyTuple_CheckExact(__pyx_v_directions)) { + __pyx_t_10 = __pyx_v_directions; __Pyx_INCREF(__pyx_t_10); __pyx_t_11 = 0; + __pyx_t_12 = NULL; + } else { + __pyx_t_11 = -1; __pyx_t_10 = PyObject_GetIter(__pyx_v_directions); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_12 = Py_TYPE(__pyx_t_10)->tp_iternext; if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 31, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_12)) { + if (likely(PyList_CheckExact(__pyx_t_10))) { + if (__pyx_t_11 >= PyList_GET_SIZE(__pyx_t_10)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_13 = PyList_GET_ITEM(__pyx_t_10, __pyx_t_11); __Pyx_INCREF(__pyx_t_13); __pyx_t_11++; if (unlikely(0 < 0)) __PYX_ERR(0, 31, __pyx_L1_error) + #else + __pyx_t_13 = PySequence_ITEM(__pyx_t_10, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + #endif + } else { + if (__pyx_t_11 >= PyTuple_GET_SIZE(__pyx_t_10)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_13 = PyTuple_GET_ITEM(__pyx_t_10, __pyx_t_11); __Pyx_INCREF(__pyx_t_13); __pyx_t_11++; if (unlikely(0 < 0)) __PYX_ERR(0, 31, __pyx_L1_error) + #else + __pyx_t_13 = PySequence_ITEM(__pyx_t_10, __pyx_t_11); __pyx_t_11++; if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + #endif + } + } else { + __pyx_t_13 = __pyx_t_12(__pyx_t_10); + if (unlikely(!__pyx_t_13)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(0, 31, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_13); + } + __Pyx_XDECREF_SET(__pyx_v_d, __pyx_t_13); + __pyx_t_13 = 0; + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":32 + * player = board[i, j] + * for d in directions: + * x, y = i, j # <<<<<<<<<<<<<< + * count = 0 + * for _ in range(5): + */ + __pyx_t_14 = __pyx_v_i; + __pyx_t_15 = __pyx_v_j; + __pyx_v_x = __pyx_t_14; + __pyx_v_y = __pyx_t_15; + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":33 + * for d in directions: + * x, y = i, j + * count = 0 # <<<<<<<<<<<<<< + * for _ in range(5): + * if x < 0 or x >= board_size or y < 0 or y >= board_size: + */ + __pyx_v_count = 0; + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":34 + * x, y = i, j + * count = 0 + * for _ in range(5): # <<<<<<<<<<<<<< + * if x < 0 or x >= board_size or y < 0 or y >= board_size: + * break + */ + for (__pyx_t_16 = 0; __pyx_t_16 < 5; __pyx_t_16+=1) { + __pyx_v__ = __pyx_t_16; + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":35 + * count = 0 + * for _ in range(5): + * if x < 0 or x >= board_size or y < 0 or y >= board_size: # <<<<<<<<<<<<<< + * break + * if board[x, y] != player: + */ + __pyx_t_17 = ((__pyx_v_x < 0) != 0); + if (!__pyx_t_17) { + } else { + __pyx_t_9 = __pyx_t_17; + goto __pyx_L13_bool_binop_done; + } + __pyx_t_17 = ((__pyx_v_x >= __pyx_v_board_size) != 0); + if (!__pyx_t_17) { + } else { + __pyx_t_9 = __pyx_t_17; + goto __pyx_L13_bool_binop_done; + } + __pyx_t_17 = ((__pyx_v_y < 0) != 0); + if (!__pyx_t_17) { + } else { + __pyx_t_9 = __pyx_t_17; + goto __pyx_L13_bool_binop_done; + } + __pyx_t_17 = ((__pyx_v_y >= __pyx_v_board_size) != 0); + __pyx_t_9 = __pyx_t_17; + __pyx_L13_bool_binop_done:; + if (__pyx_t_9) { + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":36 + * for _ in range(5): + * if x < 0 or x >= board_size or y < 0 or y >= board_size: + * break # <<<<<<<<<<<<<< + * if board[x, y] != player: + * break + */ + goto __pyx_L11_break; + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":35 + * count = 0 + * for _ in range(5): + * if x < 0 or x >= board_size or y < 0 or y >= board_size: # <<<<<<<<<<<<<< + * break + * if board[x, y] != player: + */ + } + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":37 + * if x < 0 or x >= board_size or y < 0 or y >= board_size: + * break + * if board[x, y] != player: # <<<<<<<<<<<<<< + * break + * x += d[0] + */ + __pyx_t_7 = __pyx_v_x; + __pyx_t_8 = __pyx_v_y; + __pyx_t_9 = (((*((int32_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_board.data + __pyx_t_7 * __pyx_v_board.strides[0]) ) + __pyx_t_8 * __pyx_v_board.strides[1]) ))) != __pyx_v_player) != 0); + if (__pyx_t_9) { + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":38 + * break + * if board[x, y] != player: + * break # <<<<<<<<<<<<<< + * x += d[0] + * y += d[1] + */ + goto __pyx_L11_break; + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":37 + * if x < 0 or x >= board_size or y < 0 or y >= board_size: + * break + * if board[x, y] != player: # <<<<<<<<<<<<<< + * break + * x += d[0] + */ + } + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":39 + * if board[x, y] != player: + * break + * x += d[0] # <<<<<<<<<<<<<< + * y += d[1] + * count += 1 + */ + __pyx_t_13 = __Pyx_PyInt_From_int32_t(__pyx_v_x); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_18 = __Pyx_GetItemInt(__pyx_v_d, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __pyx_t_19 = PyNumber_InPlaceAdd(__pyx_t_13, __pyx_t_18); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __pyx_t_15 = __Pyx_PyInt_As_int32_t(__pyx_t_19); if (unlikely((__pyx_t_15 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __pyx_v_x = __pyx_t_15; + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":40 + * break + * x += d[0] + * y += d[1] # <<<<<<<<<<<<<< + * count += 1 + * if count == 5: + */ + __pyx_t_19 = __Pyx_PyInt_From_int32_t(__pyx_v_y); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __pyx_t_18 = __Pyx_GetItemInt(__pyx_v_d, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __pyx_t_13 = PyNumber_InPlaceAdd(__pyx_t_19, __pyx_t_18); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 40, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __pyx_t_15 = __Pyx_PyInt_As_int32_t(__pyx_t_13); if (unlikely((__pyx_t_15 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 40, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __pyx_v_y = __pyx_t_15; + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":41 + * x += d[0] + * y += d[1] + * count += 1 # <<<<<<<<<<<<<< + * if count == 5: + * return True, player + */ + __pyx_v_count = (__pyx_v_count + 1); + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":42 + * y += d[1] + * count += 1 + * if count == 5: # <<<<<<<<<<<<<< + * return True, player + * return not has_legal_actions, -1 + */ + __pyx_t_9 = ((__pyx_v_count == 5) != 0); + if (__pyx_t_9) { + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":43 + * count += 1 + * if count == 5: + * return True, player # <<<<<<<<<<<<<< + * return not has_legal_actions, -1 + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_13 = __Pyx_PyInt_From_int32_t(__pyx_v_player); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_18 = PyTuple_New(2); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __Pyx_INCREF(Py_True); + __Pyx_GIVEREF(Py_True); + PyTuple_SET_ITEM(__pyx_t_18, 0, Py_True); + __Pyx_GIVEREF(__pyx_t_13); + PyTuple_SET_ITEM(__pyx_t_18, 1, __pyx_t_13); + __pyx_t_13 = 0; + __pyx_r = __pyx_t_18; + __pyx_t_18 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + goto __pyx_L0; + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":42 + * y += d[1] + * count += 1 + * if count == 5: # <<<<<<<<<<<<<< + * return True, player + * return not has_legal_actions, -1 + */ + } + } + __pyx_L11_break:; + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":31 + * continue + * player = board[i, j] + * for d in directions: # <<<<<<<<<<<<<< + * x, y = i, j + * count = 0 + */ + } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_L5_continue:; + } + } + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":44 + * if count == 5: + * return True, player + * return not has_legal_actions, -1 # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_10 = __Pyx_PyBool_FromLong((!(__pyx_v_has_legal_actions != 0))); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_18 = PyTuple_New(2); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 44, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __Pyx_GIVEREF(__pyx_t_10); + PyTuple_SET_ITEM(__pyx_t_18, 0, __pyx_t_10); + __Pyx_INCREF(__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_int_neg_1); + PyTuple_SET_ITEM(__pyx_t_18, 1, __pyx_int_neg_1); + __pyx_t_10 = 0; + __pyx_r = __pyx_t_18; + __pyx_t_18 = 0; + goto __pyx_L0; + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":6 + * @cython.boundscheck(False) + * @cython.wraparound(False) + * cpdef get_done_winner_cython(int32_t board_size, int32_t[:, :] board): # <<<<<<<<<<<<<< + * """ + * Overview: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_18); + __Pyx_XDECREF(__pyx_t_19); + __Pyx_AddTraceback("zoo.board_games.gomoku.envs.get_done_winner_cython.get_done_winner_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_directions); + __Pyx_XDECREF(__pyx_v_d); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_3zoo_11board_games_6gomoku_4envs_22get_done_winner_cython_1get_done_winner_cython(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static char __pyx_doc_3zoo_11board_games_6gomoku_4envs_22get_done_winner_cython_get_done_winner_cython[] = "\n Overview:\n Check if the game is over and who the winner is. Return 'done' and 'winner'.\n Arguments:\n - board_size (:obj:`int`): The size of the board.\n - board (:obj:`numpy.ndarray`): The board state.\n Returns:\n - outputs (:obj:`Tuple`): Tuple containing 'done' and 'winner',\n - if player 1 win, 'done' = True, 'winner' = 1\n - if player 2 win, 'done' = True, 'winner' = 2\n - if draw, 'done' = True, 'winner' = -1\n - if game is not over, 'done' = False, 'winner' = -1\n "; +static PyObject *__pyx_pw_3zoo_11board_games_6gomoku_4envs_22get_done_winner_cython_1get_done_winner_cython(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int32_t __pyx_v_board_size; + __Pyx_memviewslice __pyx_v_board = { 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("get_done_winner_cython (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_board_size,&__pyx_n_s_board,0}; + PyObject* values[2] = {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 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_board_size)) != 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_board)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("get_done_winner_cython", 1, 2, 2, 1); __PYX_ERR(0, 6, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "get_done_winner_cython") < 0)) __PYX_ERR(0, 6, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_board_size = __Pyx_PyInt_As_int32_t(values[0]); if (unlikely((__pyx_v_board_size == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 6, __pyx_L3_error) + __pyx_v_board = __Pyx_PyObject_to_MemoryviewSlice_dsds_nn_int32_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_board.memview)) __PYX_ERR(0, 6, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_done_winner_cython", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 6, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("zoo.board_games.gomoku.envs.get_done_winner_cython.get_done_winner_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3zoo_11board_games_6gomoku_4envs_22get_done_winner_cython_get_done_winner_cython(__pyx_self, __pyx_v_board_size, __pyx_v_board); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_3zoo_11board_games_6gomoku_4envs_22get_done_winner_cython_get_done_winner_cython(CYTHON_UNUSED PyObject *__pyx_self, int32_t __pyx_v_board_size, __Pyx_memviewslice __pyx_v_board) { + 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_done_winner_cython", 0); + __Pyx_XDECREF(__pyx_r); + if (unlikely(!__pyx_v_board.memview)) { __Pyx_RaiseUnboundLocalError("board"); __PYX_ERR(0, 6, __pyx_L1_error) } + __pyx_t_1 = __pyx_f_3zoo_11board_games_6gomoku_4envs_22get_done_winner_cython_get_done_winner_cython(__pyx_v_board_size, __pyx_v_board, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __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("zoo.board_games.gomoku.envs.get_done_winner_cython.get_done_winner_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __PYX_XDEC_MEMVIEW(&__pyx_v_board, 1); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":123 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): + * + */ + +/* Python wrapper */ +static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_shape = 0; + Py_ssize_t __pyx_v_itemsize; + PyObject *__pyx_v_format = 0; + PyObject *__pyx_v_mode = 0; + int __pyx_v_allocate_buffer; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shape,&__pyx_n_s_itemsize,&__pyx_n_s_format,&__pyx_n_s_mode,&__pyx_n_s_allocate_buffer,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[3] = ((PyObject *)__pyx_n_s_c); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shape)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_itemsize)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(1, 123, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_format)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(1, 123, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_allocate_buffer); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 123, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_shape = ((PyObject*)values[0]); + __pyx_v_itemsize = __Pyx_PyIndex_AsSsize_t(values[1]); if (unlikely((__pyx_v_itemsize == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 123, __pyx_L3_error) + __pyx_v_format = values[2]; + __pyx_v_mode = values[3]; + if (values[4]) { + __pyx_v_allocate_buffer = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_allocate_buffer == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 124, __pyx_L3_error) + } else { + + /* "View.MemoryView":124 + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, + * mode="c", bint allocate_buffer=True): # <<<<<<<<<<<<<< + * + * cdef int idx + */ + __pyx_v_allocate_buffer = ((int)1); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 123, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_shape), (&PyTuple_Type), 1, "shape", 1))) __PYX_ERR(1, 123, __pyx_L1_error) + if (unlikely(((PyObject *)__pyx_v_format) == Py_None)) { + PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "format"); __PYX_ERR(1, 123, __pyx_L1_error) + } + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v_shape, __pyx_v_itemsize, __pyx_v_format, __pyx_v_mode, __pyx_v_allocate_buffer); + + /* "View.MemoryView":123 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): + * + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer) { + int __pyx_v_idx; + Py_ssize_t __pyx_v_i; + Py_ssize_t __pyx_v_dim; + PyObject **__pyx_v_p; + char __pyx_v_order; + int __pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + char *__pyx_t_7; + int __pyx_t_8; + Py_ssize_t __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + Py_ssize_t __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + __Pyx_INCREF(__pyx_v_format); + + /* "View.MemoryView":130 + * cdef PyObject **p + * + * self.ndim = len(shape) # <<<<<<<<<<<<<< + * self.itemsize = itemsize + * + */ + if (unlikely(__pyx_v_shape == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 130, __pyx_L1_error) + } + __pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 130, __pyx_L1_error) + __pyx_v_self->ndim = ((int)__pyx_t_1); + + /* "View.MemoryView":131 + * + * self.ndim = len(shape) + * self.itemsize = itemsize # <<<<<<<<<<<<<< + * + * if not self.ndim: + */ + __pyx_v_self->itemsize = __pyx_v_itemsize; + + /* "View.MemoryView":133 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError("Empty shape tuple for cython.array") + * + */ + __pyx_t_2 = ((!(__pyx_v_self->ndim != 0)) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":134 + * + * if not self.ndim: + * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< + * + * if itemsize <= 0: + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 134, __pyx_L1_error) + + /* "View.MemoryView":133 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError("Empty shape tuple for cython.array") + * + */ + } + + /* "View.MemoryView":136 + * raise ValueError("Empty shape tuple for cython.array") + * + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError("itemsize <= 0 for cython.array") + * + */ + __pyx_t_2 = ((__pyx_v_itemsize <= 0) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":137 + * + * if itemsize <= 0: + * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< + * + * if not isinstance(format, bytes): + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 137, __pyx_L1_error) + + /* "View.MemoryView":136 + * raise ValueError("Empty shape tuple for cython.array") + * + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError("itemsize <= 0 for cython.array") + * + */ + } + + /* "View.MemoryView":139 + * raise ValueError("itemsize <= 0 for cython.array") + * + * if not isinstance(format, bytes): # <<<<<<<<<<<<<< + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string + */ + __pyx_t_2 = PyBytes_Check(__pyx_v_format); + __pyx_t_4 = ((!(__pyx_t_2 != 0)) != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":140 + * + * if not isinstance(format, bytes): + * format = format.encode('ASCII') # <<<<<<<<<<<<<< + * self._format = format # keep a reference to the byte string + * self.format = self._format + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_n_s_ASCII) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_n_s_ASCII); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":139 + * raise ValueError("itemsize <= 0 for cython.array") + * + * if not isinstance(format, bytes): # <<<<<<<<<<<<<< + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string + */ + } + + /* "View.MemoryView":141 + * if not isinstance(format, bytes): + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string # <<<<<<<<<<<<<< + * self.format = self._format + * + */ + if (!(likely(PyBytes_CheckExact(__pyx_v_format))||((__pyx_v_format) == Py_None)||((void)PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v_format)->tp_name), 0))) __PYX_ERR(1, 141, __pyx_L1_error) + __pyx_t_3 = __pyx_v_format; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->_format); + __Pyx_DECREF(__pyx_v_self->_format); + __pyx_v_self->_format = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":142 + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string + * self.format = self._format # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(__pyx_v_self->_format == Py_None)) { + PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); + __PYX_ERR(1, 142, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(1, 142, __pyx_L1_error) + __pyx_v_self->format = __pyx_t_7; + + /* "View.MemoryView":145 + * + * + * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) # <<<<<<<<<<<<<< + * self._strides = self._shape + self.ndim + * + */ + __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2))); + + /* "View.MemoryView":146 + * + * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) + * self._strides = self._shape + self.ndim # <<<<<<<<<<<<<< + * + * if not self._shape: + */ + __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim); + + /* "View.MemoryView":148 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate shape and strides.") + * + */ + __pyx_t_4 = ((!(__pyx_v_self->_shape != 0)) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":149 + * + * if not self._shape: + * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 149, __pyx_L1_error) + + /* "View.MemoryView":148 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate shape and strides.") + * + */ + } + + /* "View.MemoryView":152 + * + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + */ + __pyx_t_8 = 0; + __pyx_t_3 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0; + for (;;) { + if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(1, 152, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 152, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_dim = __pyx_t_9; + __pyx_v_idx = __pyx_t_8; + __pyx_t_8 = (__pyx_t_8 + 1); + + /* "View.MemoryView":153 + * + * for idx, dim in enumerate(shape): + * if dim <= 0: # <<<<<<<<<<<<<< + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim + */ + __pyx_t_4 = ((__pyx_v_dim <= 0) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":154 + * for idx, dim in enumerate(shape): + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) # <<<<<<<<<<<<<< + * self._shape[idx] = dim + * + */ + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_6); + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 154, __pyx_L1_error) + + /* "View.MemoryView":153 + * + * for idx, dim in enumerate(shape): + * if dim <= 0: # <<<<<<<<<<<<<< + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim + */ + } + + /* "View.MemoryView":155 + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim # <<<<<<<<<<<<<< + * + * cdef char order + */ + (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim; + + /* "View.MemoryView":152 + * + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":158 + * + * cdef char order + * if mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' + */ + __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 158, __pyx_L1_error) + if (__pyx_t_4) { + + /* "View.MemoryView":159 + * cdef char order + * if mode == 'fortran': + * order = b'F' # <<<<<<<<<<<<<< + * self.mode = u'fortran' + * elif mode == 'c': + */ + __pyx_v_order = 'F'; + + /* "View.MemoryView":160 + * if mode == 'fortran': + * order = b'F' + * self.mode = u'fortran' # <<<<<<<<<<<<<< + * elif mode == 'c': + * order = b'C' + */ + __Pyx_INCREF(__pyx_n_u_fortran); + __Pyx_GIVEREF(__pyx_n_u_fortran); + __Pyx_GOTREF(__pyx_v_self->mode); + __Pyx_DECREF(__pyx_v_self->mode); + __pyx_v_self->mode = __pyx_n_u_fortran; + + /* "View.MemoryView":158 + * + * cdef char order + * if mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' + */ + goto __pyx_L10; + } + + /* "View.MemoryView":161 + * order = b'F' + * self.mode = u'fortran' + * elif mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' + */ + __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_c, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 161, __pyx_L1_error) + if (likely(__pyx_t_4)) { + + /* "View.MemoryView":162 + * self.mode = u'fortran' + * elif mode == 'c': + * order = b'C' # <<<<<<<<<<<<<< + * self.mode = u'c' + * else: + */ + __pyx_v_order = 'C'; + + /* "View.MemoryView":163 + * elif mode == 'c': + * order = b'C' + * self.mode = u'c' # <<<<<<<<<<<<<< + * else: + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) + */ + __Pyx_INCREF(__pyx_n_u_c); + __Pyx_GIVEREF(__pyx_n_u_c); + __Pyx_GOTREF(__pyx_v_self->mode); + __Pyx_DECREF(__pyx_v_self->mode); + __pyx_v_self->mode = __pyx_n_u_c; + + /* "View.MemoryView":161 + * order = b'F' + * self.mode = u'fortran' + * elif mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' + */ + goto __pyx_L10; + } + + /* "View.MemoryView":165 + * self.mode = u'c' + * else: + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) # <<<<<<<<<<<<<< + * + * self.len = fill_contig_strides_array(self._shape, self._strides, + */ + /*else*/ { + __pyx_t_3 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_v_mode); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 165, __pyx_L1_error) + } + __pyx_L10:; + + /* "View.MemoryView":167 + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) + * + * self.len = fill_contig_strides_array(self._shape, self._strides, # <<<<<<<<<<<<<< + * itemsize, self.ndim, order) + * + */ + __pyx_v_self->len = __pyx_fill_contig_strides_array(__pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_itemsize, __pyx_v_self->ndim, __pyx_v_order); + + /* "View.MemoryView":170 + * itemsize, self.ndim, order) + * + * self.free_data = allocate_buffer # <<<<<<<<<<<<<< + * self.dtype_is_object = format == b'O' + * if allocate_buffer: + */ + __pyx_v_self->free_data = __pyx_v_allocate_buffer; + + /* "View.MemoryView":171 + * + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<< + * if allocate_buffer: + * + */ + __pyx_t_10 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 171, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 171, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_v_self->dtype_is_object = __pyx_t_4; + + /* "View.MemoryView":172 + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' + * if allocate_buffer: # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = (__pyx_v_allocate_buffer != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":175 + * + * + * self.data = malloc(self.len) # <<<<<<<<<<<<<< + * if not self.data: + * raise MemoryError("unable to allocate array data.") + */ + __pyx_v_self->data = ((char *)malloc(__pyx_v_self->len)); + + /* "View.MemoryView":176 + * + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate array data.") + * + */ + __pyx_t_4 = ((!(__pyx_v_self->data != 0)) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":177 + * self.data = malloc(self.len) + * if not self.data: + * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< + * + * if self.dtype_is_object: + */ + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 177, __pyx_L1_error) + + /* "View.MemoryView":176 + * + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate array data.") + * + */ + } + + /* "View.MemoryView":179 + * raise MemoryError("unable to allocate array data.") + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len / itemsize): + */ + __pyx_t_4 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":180 + * + * if self.dtype_is_object: + * p = self.data # <<<<<<<<<<<<<< + * for i in range(self.len / itemsize): + * p[i] = Py_None + */ + __pyx_v_p = ((PyObject **)__pyx_v_self->data); + + /* "View.MemoryView":181 + * if self.dtype_is_object: + * p = self.data + * for i in range(self.len / itemsize): # <<<<<<<<<<<<<< + * p[i] = Py_None + * Py_INCREF(Py_None) + */ + if (unlikely(__pyx_v_itemsize == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); + __PYX_ERR(1, 181, __pyx_L1_error) + } + else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) { + PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); + __PYX_ERR(1, 181, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_itemsize); + __pyx_t_9 = __pyx_t_1; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_9; __pyx_t_11+=1) { + __pyx_v_i = __pyx_t_11; + + /* "View.MemoryView":182 + * p = self.data + * for i in range(self.len / itemsize): + * p[i] = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * + */ + (__pyx_v_p[__pyx_v_i]) = Py_None; + + /* "View.MemoryView":183 + * for i in range(self.len / itemsize): + * p[i] = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + Py_INCREF(Py_None); + } + + /* "View.MemoryView":179 + * raise MemoryError("unable to allocate array data.") + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len / itemsize): + */ + } + + /* "View.MemoryView":172 + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' + * if allocate_buffer: # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":123 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_format); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":186 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * cdef int bufmode = -1 + * if self.mode == u"c": + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(((struct __pyx_array_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_bufmode; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + char *__pyx_t_4; + Py_ssize_t __pyx_t_5; + int __pyx_t_6; + Py_ssize_t *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + if (__pyx_v_info == NULL) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + + /* "View.MemoryView":187 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 # <<<<<<<<<<<<<< + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + */ + __pyx_v_bufmode = -1; + + /* "View.MemoryView":188 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + */ + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_c, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 188, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":189 + * cdef int bufmode = -1 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + */ + __pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); + + /* "View.MemoryView":188 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + */ + goto __pyx_L3; + } + + /* "View.MemoryView":190 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": # <<<<<<<<<<<<<< + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + */ + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 190, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":191 + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") + */ + __pyx_v_bufmode = (PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); + + /* "View.MemoryView":190 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": # <<<<<<<<<<<<<< + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + */ + } + __pyx_L3:; + + /* "View.MemoryView":192 + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): # <<<<<<<<<<<<<< + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data + */ + __pyx_t_1 = ((!((__pyx_v_flags & __pyx_v_bufmode) != 0)) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":193 + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") # <<<<<<<<<<<<<< + * info.buf = self.data + * info.len = self.len + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 193, __pyx_L1_error) + + /* "View.MemoryView":192 + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): # <<<<<<<<<<<<<< + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data + */ + } + + /* "View.MemoryView":194 + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data # <<<<<<<<<<<<<< + * info.len = self.len + * info.ndim = self.ndim + */ + __pyx_t_4 = __pyx_v_self->data; + __pyx_v_info->buf = __pyx_t_4; + + /* "View.MemoryView":195 + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data + * info.len = self.len # <<<<<<<<<<<<<< + * info.ndim = self.ndim + * info.shape = self._shape + */ + __pyx_t_5 = __pyx_v_self->len; + __pyx_v_info->len = __pyx_t_5; + + /* "View.MemoryView":196 + * info.buf = self.data + * info.len = self.len + * info.ndim = self.ndim # <<<<<<<<<<<<<< + * info.shape = self._shape + * info.strides = self._strides + */ + __pyx_t_6 = __pyx_v_self->ndim; + __pyx_v_info->ndim = __pyx_t_6; + + /* "View.MemoryView":197 + * info.len = self.len + * info.ndim = self.ndim + * info.shape = self._shape # <<<<<<<<<<<<<< + * info.strides = self._strides + * info.suboffsets = NULL + */ + __pyx_t_7 = __pyx_v_self->_shape; + __pyx_v_info->shape = __pyx_t_7; + + /* "View.MemoryView":198 + * info.ndim = self.ndim + * info.shape = self._shape + * info.strides = self._strides # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = self.itemsize + */ + __pyx_t_7 = __pyx_v_self->_strides; + __pyx_v_info->strides = __pyx_t_7; + + /* "View.MemoryView":199 + * info.shape = self._shape + * info.strides = self._strides + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = self.itemsize + * info.readonly = 0 + */ + __pyx_v_info->suboffsets = NULL; + + /* "View.MemoryView":200 + * info.strides = self._strides + * info.suboffsets = NULL + * info.itemsize = self.itemsize # <<<<<<<<<<<<<< + * info.readonly = 0 + * + */ + __pyx_t_5 = __pyx_v_self->itemsize; + __pyx_v_info->itemsize = __pyx_t_5; + + /* "View.MemoryView":201 + * info.suboffsets = NULL + * info.itemsize = self.itemsize + * info.readonly = 0 # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + __pyx_v_info->readonly = 0; + + /* "View.MemoryView":203 + * info.readonly = 0 + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.format + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":204 + * + * if flags & PyBUF_FORMAT: + * info.format = self.format # <<<<<<<<<<<<<< + * else: + * info.format = NULL + */ + __pyx_t_4 = __pyx_v_self->format; + __pyx_v_info->format = __pyx_t_4; + + /* "View.MemoryView":203 + * info.readonly = 0 + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.format + * else: + */ + goto __pyx_L5; + } + + /* "View.MemoryView":206 + * info.format = self.format + * else: + * info.format = NULL # <<<<<<<<<<<<<< + * + * info.obj = self + */ + /*else*/ { + __pyx_v_info->format = NULL; + } + __pyx_L5:; + + /* "View.MemoryView":208 + * info.format = NULL + * + * info.obj = self # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + */ + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + + /* "View.MemoryView":186 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * cdef int bufmode = -1 + * if self.mode == u"c": + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.array.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":212 + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + * + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + */ + +/* Python wrapper */ +static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_array___dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":213 + * + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data: + */ + __pyx_t_1 = ((__pyx_v_self->callback_free_data != NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":214 + * def __dealloc__(array self): + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) # <<<<<<<<<<<<<< + * elif self.free_data: + * if self.dtype_is_object: + */ + __pyx_v_self->callback_free_data(__pyx_v_self->data); + + /* "View.MemoryView":213 + * + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":215 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, + */ + __pyx_t_1 = (__pyx_v_self->free_data != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":216 + * self.callback_free_data(self.data) + * elif self.free_data: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + */ + __pyx_t_1 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":217 + * elif self.free_data: + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, # <<<<<<<<<<<<<< + * self._strides, self.ndim, False) + * free(self.data) + */ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_self->data, __pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_self->ndim, 0); + + /* "View.MemoryView":216 + * self.callback_free_data(self.data) + * elif self.free_data: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + */ + } + + /* "View.MemoryView":219 + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + * free(self.data) # <<<<<<<<<<<<<< + * PyObject_Free(self._shape) + * + */ + free(__pyx_v_self->data); + + /* "View.MemoryView":215 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, + */ + } + __pyx_L3:; + + /* "View.MemoryView":220 + * self._strides, self.ndim, False) + * free(self.data) + * PyObject_Free(self._shape) # <<<<<<<<<<<<<< + * + * @property + */ + PyObject_Free(__pyx_v_self->_shape); + + /* "View.MemoryView":212 + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + * + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":223 + * + * @property + * def memview(self): # <<<<<<<<<<<<<< + * return self.get_memview() + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_5array_7memview___get__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":224 + * @property + * def memview(self): + * return self.get_memview() # <<<<<<<<<<<<<< + * + * @cname('get_memview') + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_array *)__pyx_v_self->__pyx_vtab)->get_memview(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":223 + * + * @property + * def memview(self): # <<<<<<<<<<<<<< + * return self.get_memview() + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.memview.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":227 + * + * @cname('get_memview') + * cdef get_memview(self): # <<<<<<<<<<<<<< + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) + */ + +static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) { + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_memview", 0); + + /* "View.MemoryView":228 + * @cname('get_memview') + * cdef get_memview(self): + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE # <<<<<<<<<<<<<< + * return memoryview(self, flags, self.dtype_is_object) + * + */ + __pyx_v_flags = ((PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) | PyBUF_WRITABLE); + + /* "View.MemoryView":229 + * cdef get_memview(self): + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) # <<<<<<<<<<<<<< + * + * def __len__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":227 + * + * @cname('get_memview') + * cdef get_memview(self): # <<<<<<<<<<<<<< + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.array.get_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":231 + * return memoryview(self, flags, self.dtype_is_object) + * + * def __len__(self): # <<<<<<<<<<<<<< + * return self._shape[0] + * + */ + +/* Python wrapper */ +static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self); /*proto*/ +static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__", 0); + + /* "View.MemoryView":232 + * + * def __len__(self): + * return self._shape[0] # <<<<<<<<<<<<<< + * + * def __getattr__(self, attr): + */ + __pyx_r = (__pyx_v_self->_shape[0]); + goto __pyx_L0; + + /* "View.MemoryView":231 + * return memoryview(self, flags, self.dtype_is_object) + * + * def __len__(self): # <<<<<<<<<<<<<< + * return self._shape[0] + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":234 + * return self._shape[0] + * + * def __getattr__(self, attr): # <<<<<<<<<<<<<< + * return getattr(self.memview, attr) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr); /*proto*/ +static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_attr)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getattr__", 0); + + /* "View.MemoryView":235 + * + * def __getattr__(self, attr): + * return getattr(self.memview, attr) # <<<<<<<<<<<<<< + * + * def __getitem__(self, item): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_GetAttr(__pyx_t_1, __pyx_v_attr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":234 + * return self._shape[0] + * + * def __getattr__(self, attr): # <<<<<<<<<<<<<< + * return getattr(self.memview, attr) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.array.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":237 + * return getattr(self.memview, attr) + * + * def __getitem__(self, item): # <<<<<<<<<<<<<< + * return self.memview[item] + * + */ + +/* Python wrapper */ +static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/ +static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "View.MemoryView":238 + * + * def __getitem__(self, item): + * return self.memview[item] # <<<<<<<<<<<<<< + * + * def __setitem__(self, item, value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":237 + * return getattr(self.memview, attr) + * + * def __getitem__(self, item): # <<<<<<<<<<<<<< + * return self.memview[item] + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":240 + * return self.memview[item] + * + * def __setitem__(self, item, value): # <<<<<<<<<<<<<< + * self.memview[item] = value + * + */ + +/* Python wrapper */ +static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + + /* "View.MemoryView":241 + * + * def __setitem__(self, item, value): + * self.memview[item] = value # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_item, __pyx_v_value) < 0)) __PYX_ERR(1, 241, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":240 + * return self.memview[item] + * + * def __setitem__(self, item, value): # <<<<<<<<<<<<<< + * self.memview[item] = value + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__11, 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__12, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":245 + * + * @cname("__pyx_array_new") + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< + * char *mode, char *buf): + * cdef array result + */ + +static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, char *__pyx_v_format, char *__pyx_v_mode, char *__pyx_v_buf) { + struct __pyx_array_obj *__pyx_v_result = 0; + struct __pyx_array_obj *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("array_cwrapper", 0); + + /* "View.MemoryView":249 + * cdef array result + * + * if buf == NULL: # <<<<<<<<<<<<<< + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + */ + __pyx_t_1 = ((__pyx_v_buf == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":250 + * + * if buf == NULL: + * result = array(shape, itemsize, format, mode.decode('ASCII')) # <<<<<<<<<<<<<< + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), + */ + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_shape); + __Pyx_GIVEREF(__pyx_v_shape); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_shape); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":249 + * cdef array result + * + * if buf == NULL: # <<<<<<<<<<<<<< + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":252 + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< + * allocate_buffer=False) + * result.data = buf + */ + /*else*/ { + __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_shape); + __Pyx_GIVEREF(__pyx_v_shape); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_shape); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_3 = 0; + + /* "View.MemoryView":253 + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), + * allocate_buffer=False) # <<<<<<<<<<<<<< + * result.data = buf + * + */ + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 253, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(1, 253, __pyx_L1_error) + + /* "View.MemoryView":252 + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< + * allocate_buffer=False) + * result.data = buf + */ + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_5); + __pyx_t_5 = 0; + + /* "View.MemoryView":254 + * result = array(shape, itemsize, format, mode.decode('ASCII'), + * allocate_buffer=False) + * result.data = buf # <<<<<<<<<<<<<< + * + * return result + */ + __pyx_v_result->data = __pyx_v_buf; + } + __pyx_L3:; + + /* "View.MemoryView":256 + * result.data = buf + * + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "View.MemoryView":245 + * + * @cname("__pyx_array_new") + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< + * char *mode, char *buf): + * cdef array result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":282 + * cdef class Enum(object): + * cdef object name + * def __init__(self, name): # <<<<<<<<<<<<<< + * self.name = name + * def __repr__(self): + */ + +/* Python wrapper */ +static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_name = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 282, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_name = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 282, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.Enum.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v_name); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__", 0); + + /* "View.MemoryView":283 + * cdef object name + * def __init__(self, name): + * self.name = name # <<<<<<<<<<<<<< + * def __repr__(self): + * return self.name + */ + __Pyx_INCREF(__pyx_v_name); + __Pyx_GIVEREF(__pyx_v_name); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = __pyx_v_name; + + /* "View.MemoryView":282 + * cdef class Enum(object): + * cdef object name + * def __init__(self, name): # <<<<<<<<<<<<<< + * self.name = name + * def __repr__(self): + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":284 + * def __init__(self, name): + * self.name = name + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name + * + */ + +/* Python wrapper */ +static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "View.MemoryView":285 + * self.name = name + * def __repr__(self): + * return self.name # <<<<<<<<<<<<<< + * + * cdef generic = Enum("") + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->name); + __pyx_r = __pyx_v_self->name; + goto __pyx_L0; + + /* "View.MemoryView":284 + * def __init__(self, name): + * self.name = name + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_MemviewEnum___reduce_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.name,) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->name); + __Pyx_GIVEREF(__pyx_v_self->name); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict); + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.name is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.name is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + */ + /*else*/ { + __pyx_t_3 = (__pyx_v_self->name != Py_None); + __pyx_v_use_setstate = __pyx_t_3; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + */ + __pyx_t_3 = (__pyx_v_use_setstate != 0); + if (__pyx_t_3) { + + /* "(tree fragment)":13 + * use_setstate = self.name is not None + * if use_setstate: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_INCREF(__pyx_int_184977713); + __Pyx_GIVEREF(__pyx_int_184977713); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Enum__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_INCREF(__pyx_int_184977713); + __Pyx_GIVEREF(__pyx_int_184977713); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.Enum.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Enum__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||((void)PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_unpickle_Enum__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":299 + * + * @cname('__pyx_align_pointer') + * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory + */ + +static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) { + Py_intptr_t __pyx_v_aligned_p; + size_t __pyx_v_offset; + void *__pyx_r; + int __pyx_t_1; + + /* "View.MemoryView":301 + * cdef void *align_pointer(void *memory, size_t alignment) nogil: + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory # <<<<<<<<<<<<<< + * cdef size_t offset + * + */ + __pyx_v_aligned_p = ((Py_intptr_t)__pyx_v_memory); + + /* "View.MemoryView":305 + * + * with cython.cdivision(True): + * offset = aligned_p % alignment # <<<<<<<<<<<<<< + * + * if offset > 0: + */ + __pyx_v_offset = (__pyx_v_aligned_p % __pyx_v_alignment); + + /* "View.MemoryView":307 + * offset = aligned_p % alignment + * + * if offset > 0: # <<<<<<<<<<<<<< + * aligned_p += alignment - offset + * + */ + __pyx_t_1 = ((__pyx_v_offset > 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":308 + * + * if offset > 0: + * aligned_p += alignment - offset # <<<<<<<<<<<<<< + * + * return aligned_p + */ + __pyx_v_aligned_p = (__pyx_v_aligned_p + (__pyx_v_alignment - __pyx_v_offset)); + + /* "View.MemoryView":307 + * offset = aligned_p % alignment + * + * if offset > 0: # <<<<<<<<<<<<<< + * aligned_p += alignment - offset + * + */ + } + + /* "View.MemoryView":310 + * aligned_p += alignment - offset + * + * return aligned_p # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((void *)__pyx_v_aligned_p); + goto __pyx_L0; + + /* "View.MemoryView":299 + * + * @cname('__pyx_align_pointer') + * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":346 + * cdef __Pyx_TypeInfo *typeinfo + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< + * self.obj = obj + * self.flags = flags + */ + +/* Python wrapper */ +static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_obj = 0; + int __pyx_v_flags; + int __pyx_v_dtype_is_object; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_obj)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 346, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dtype_is_object); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 346, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_obj = values[0]; + __pyx_v_flags = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 346, __pyx_L3_error) + if (values[2]) { + __pyx_v_dtype_is_object = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_dtype_is_object == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 346, __pyx_L3_error) + } else { + __pyx_v_dtype_is_object = ((int)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 346, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_obj, __pyx_v_flags, __pyx_v_dtype_is_object); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "View.MemoryView":347 + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): + * self.obj = obj # <<<<<<<<<<<<<< + * self.flags = flags + * if type(self) is memoryview or obj is not None: + */ + __Pyx_INCREF(__pyx_v_obj); + __Pyx_GIVEREF(__pyx_v_obj); + __Pyx_GOTREF(__pyx_v_self->obj); + __Pyx_DECREF(__pyx_v_self->obj); + __pyx_v_self->obj = __pyx_v_obj; + + /* "View.MemoryView":348 + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): + * self.obj = obj + * self.flags = flags # <<<<<<<<<<<<<< + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) + */ + __pyx_v_self->flags = __pyx_v_flags; + + /* "View.MemoryView":349 + * self.obj = obj + * self.flags = flags + * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: + */ + __pyx_t_2 = (((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))) == ((PyObject *)__pyx_memoryview_type)); + __pyx_t_3 = (__pyx_t_2 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = (__pyx_v_obj != Py_None); + __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "View.MemoryView":350 + * self.flags = flags + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) # <<<<<<<<<<<<<< + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None + */ + __pyx_t_4 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 350, __pyx_L1_error) + + /* "View.MemoryView":351 + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) + */ + __pyx_t_1 = ((((PyObject *)__pyx_v_self->view.obj) == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":352 + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * + */ + ((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None; + + /* "View.MemoryView":353 + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + */ + Py_INCREF(Py_None); + + /* "View.MemoryView":351 + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) + */ + } + + /* "View.MemoryView":349 + * self.obj = obj + * self.flags = flags + * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: + */ + } + + /* "View.MemoryView":355 + * Py_INCREF(Py_None) + * + * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + */ + __pyx_t_1 = ((!(__PYX_CYTHON_ATOMICS_ENABLED() != 0)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":357 + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + */ + __pyx_t_1 = ((__pyx_memoryview_thread_locks_used < 8) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":358 + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: + */ + __pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); + + /* "View.MemoryView":359 + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 # <<<<<<<<<<<<<< + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + */ + __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1); + + /* "View.MemoryView":357 + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + */ + } + + /* "View.MemoryView":360 + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: # <<<<<<<<<<<<<< + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + */ + __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":361 + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() # <<<<<<<<<<<<<< + * if self.lock is NULL: + * raise MemoryError + */ + __pyx_v_self->lock = PyThread_allocate_lock(); + + /* "View.MemoryView":362 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * + */ + __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":363 + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + PyErr_NoMemory(); __PYX_ERR(1, 363, __pyx_L1_error) + + /* "View.MemoryView":362 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * + */ + } + + /* "View.MemoryView":360 + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: # <<<<<<<<<<<<<< + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + */ + } + + /* "View.MemoryView":355 + * Py_INCREF(Py_None) + * + * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + */ + } + + /* "View.MemoryView":365 + * raise MemoryError + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":366 + * + * if flags & PyBUF_FORMAT: + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') # <<<<<<<<<<<<<< + * else: + * self.dtype_is_object = dtype_is_object + */ + __pyx_t_2 = (((__pyx_v_self->view.format[0]) == 'O') != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L12_bool_binop_done; + } + __pyx_t_2 = (((__pyx_v_self->view.format[1]) == '\x00') != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L12_bool_binop_done:; + __pyx_v_self->dtype_is_object = __pyx_t_1; + + /* "View.MemoryView":365 + * raise MemoryError + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: + */ + goto __pyx_L11; + } + + /* "View.MemoryView":368 + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: + * self.dtype_is_object = dtype_is_object # <<<<<<<<<<<<<< + * + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( + */ + /*else*/ { + __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object; + } + __pyx_L11:; + + /* "View.MemoryView":370 + * self.dtype_is_object = dtype_is_object + * + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( # <<<<<<<<<<<<<< + * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) + * self.typeinfo = NULL + */ + __pyx_v_self->acquisition_count_aligned_p = ((__pyx_atomic_int *)__pyx_align_pointer(((void *)(&(__pyx_v_self->acquisition_count[0]))), (sizeof(__pyx_atomic_int)))); + + /* "View.MemoryView":372 + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( + * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) + * self.typeinfo = NULL # <<<<<<<<<<<<<< + * + * def __dealloc__(memoryview self): + */ + __pyx_v_self->typeinfo = NULL; + + /* "View.MemoryView":346 + * cdef __Pyx_TypeInfo *typeinfo + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< + * self.obj = obj + * self.flags = flags + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":374 + * self.typeinfo = NULL + * + * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + */ + +/* Python wrapper */ +static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self) { + int __pyx_v_i; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyThread_type_lock __pyx_t_6; + PyThread_type_lock __pyx_t_7; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":375 + * + * def __dealloc__(memoryview self): + * if self.obj is not None: # <<<<<<<<<<<<<< + * __Pyx_ReleaseBuffer(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + */ + __pyx_t_1 = (__pyx_v_self->obj != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":376 + * def __dealloc__(memoryview self): + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) # <<<<<<<<<<<<<< + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + * + */ + __Pyx_ReleaseBuffer((&__pyx_v_self->view)); + + /* "View.MemoryView":375 + * + * def __dealloc__(memoryview self): + * if self.obj is not None: # <<<<<<<<<<<<<< + * __Pyx_ReleaseBuffer(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":377 + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< + * + * (<__pyx_buffer *> &self.view).obj = NULL + */ + __pyx_t_2 = ((((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":379 + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + * + * (<__pyx_buffer *> &self.view).obj = NULL # <<<<<<<<<<<<<< + * Py_DECREF(Py_None) + * + */ + ((Py_buffer *)(&__pyx_v_self->view))->obj = NULL; + + /* "View.MemoryView":380 + * + * (<__pyx_buffer *> &self.view).obj = NULL + * Py_DECREF(Py_None) # <<<<<<<<<<<<<< + * + * cdef int i + */ + Py_DECREF(Py_None); + + /* "View.MemoryView":377 + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< + * + * (<__pyx_buffer *> &self.view).obj = NULL + */ + } + __pyx_L3:; + + /* "View.MemoryView":384 + * cdef int i + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: # <<<<<<<<<<<<<< + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: + */ + __pyx_t_2 = ((__pyx_v_self->lock != NULL) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":385 + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: + * for i in range(__pyx_memoryview_thread_locks_used): # <<<<<<<<<<<<<< + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + */ + __pyx_t_3 = __pyx_memoryview_thread_locks_used; + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "View.MemoryView":386 + * if self.lock != NULL: + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + */ + __pyx_t_2 = (((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":387 + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 # <<<<<<<<<<<<<< + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + */ + __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used - 1); + + /* "View.MemoryView":388 + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + */ + __pyx_t_2 = ((__pyx_v_i != __pyx_memoryview_thread_locks_used) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":390 + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) # <<<<<<<<<<<<<< + * break + * else: + */ + __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); + __pyx_t_7 = (__pyx_memoryview_thread_locks[__pyx_v_i]); + + /* "View.MemoryView":389 + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + * break + */ + (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_6; + (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_7; + + /* "View.MemoryView":388 + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + */ + } + + /* "View.MemoryView":391 + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + * break # <<<<<<<<<<<<<< + * else: + * PyThread_free_lock(self.lock) + */ + goto __pyx_L6_break; + + /* "View.MemoryView":386 + * if self.lock != NULL: + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + */ + } + } + /*else*/ { + + /* "View.MemoryView":393 + * break + * else: + * PyThread_free_lock(self.lock) # <<<<<<<<<<<<<< + * + * cdef char *get_item_pointer(memoryview self, object index) except NULL: + */ + PyThread_free_lock(__pyx_v_self->lock); + } + __pyx_L6_break:; + + /* "View.MemoryView":384 + * cdef int i + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: # <<<<<<<<<<<<<< + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: + */ + } + + /* "View.MemoryView":374 + * self.typeinfo = NULL + * + * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":395 + * PyThread_free_lock(self.lock) + * + * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf + */ + +static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { + Py_ssize_t __pyx_v_dim; + char *__pyx_v_itemp; + PyObject *__pyx_v_idx = NULL; + char *__pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *(*__pyx_t_4)(PyObject *); + PyObject *__pyx_t_5 = NULL; + Py_ssize_t __pyx_t_6; + char *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_item_pointer", 0); + + /* "View.MemoryView":397 + * cdef char *get_item_pointer(memoryview self, object index) except NULL: + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf # <<<<<<<<<<<<<< + * + * for dim, idx in enumerate(index): + */ + __pyx_v_itemp = ((char *)__pyx_v_self->view.buf); + + /* "View.MemoryView":399 + * cdef char *itemp = self.view.buf + * + * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * + */ + __pyx_t_1 = 0; + if (likely(PyList_CheckExact(__pyx_v_index)) || PyTuple_CheckExact(__pyx_v_index)) { + __pyx_t_2 = __pyx_v_index; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 399, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 399, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } else { + if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 399, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } + } else { + __pyx_t_5 = __pyx_t_4(__pyx_t_2); + if (unlikely(!__pyx_t_5)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 399, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_v_dim = __pyx_t_1; + __pyx_t_1 = (__pyx_t_1 + 1); + + /* "View.MemoryView":400 + * + * for dim, idx in enumerate(index): + * itemp = pybuffer_index(&self.view, itemp, idx, dim) # <<<<<<<<<<<<<< + * + * return itemp + */ + __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 400, __pyx_L1_error) + __pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(1, 400, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_7; + + /* "View.MemoryView":399 + * cdef char *itemp = self.view.buf + * + * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":402 + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * + * return itemp # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_itemp; + goto __pyx_L0; + + /* "View.MemoryView":395 + * PyThread_free_lock(self.lock) + * + * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.get_item_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_idx); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":405 + * + * + * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< + * if index is Ellipsis: + * return self + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index); /*proto*/ +static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { + PyObject *__pyx_v_have_slices = NULL; + PyObject *__pyx_v_indices = NULL; + char *__pyx_v_itemp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + char *__pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "View.MemoryView":406 + * + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self + * + */ + __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":407 + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: + * return self # <<<<<<<<<<<<<< + * + * have_slices, indices = _unellipsify(index, self.view.ndim) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "View.MemoryView":406 + * + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self + * + */ + } + + /* "View.MemoryView":409 + * return self + * + * have_slices, indices = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< + * + * cdef char *itemp + */ + __pyx_t_3 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (likely(__pyx_t_3 != Py_None)) { + PyObject* sequence = __pyx_t_3; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 409, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + #else + __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 409, __pyx_L1_error) + } + __pyx_v_have_slices = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_v_indices = __pyx_t_5; + __pyx_t_5 = 0; + + /* "View.MemoryView":412 + * + * cdef char *itemp + * if have_slices: # <<<<<<<<<<<<<< + * return memview_slice(self, indices) + * else: + */ + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 412, __pyx_L1_error) + if (__pyx_t_2) { + + /* "View.MemoryView":413 + * cdef char *itemp + * if have_slices: + * return memview_slice(self, indices) # <<<<<<<<<<<<<< + * else: + * itemp = self.get_item_pointer(indices) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":412 + * + * cdef char *itemp + * if have_slices: # <<<<<<<<<<<<<< + * return memview_slice(self, indices) + * else: + */ + } + + /* "View.MemoryView":415 + * return memview_slice(self, indices) + * else: + * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< + * return self.convert_item_to_object(itemp) + * + */ + /*else*/ { + __pyx_t_6 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_6 == ((char *)NULL))) __PYX_ERR(1, 415, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_6; + + /* "View.MemoryView":416 + * else: + * itemp = self.get_item_pointer(indices) + * return self.convert_item_to_object(itemp) # <<<<<<<<<<<<<< + * + * def __setitem__(memoryview self, object index, object value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":405 + * + * + * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< + * if index is Ellipsis: + * return self + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_have_slices); + __Pyx_XDECREF(__pyx_v_indices); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":418 + * return self.convert_item_to_object(itemp) + * + * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") + */ + +/* Python wrapper */ +static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + PyObject *__pyx_v_have_slices = NULL; + PyObject *__pyx_v_obj = NULL; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + __Pyx_INCREF(__pyx_v_index); + + /* "View.MemoryView":419 + * + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError("Cannot assign to read-only memoryview") + * + */ + __pyx_t_1 = (__pyx_v_self->view.readonly != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":420 + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< + * + * have_slices, index = _unellipsify(index, self.view.ndim) + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 420, __pyx_L1_error) + + /* "View.MemoryView":419 + * + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError("Cannot assign to read-only memoryview") + * + */ + } + + /* "View.MemoryView":422 + * raise TypeError("Cannot assign to read-only memoryview") + * + * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< + * + * if have_slices: + */ + __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(__pyx_t_2 != Py_None)) { + PyObject* sequence = __pyx_t_2; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 422, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 422, __pyx_L1_error) + } + __pyx_v_have_slices = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":424 + * have_slices, index = _unellipsify(index, self.view.ndim) + * + * if have_slices: # <<<<<<<<<<<<<< + * obj = self.is_slice(value) + * if obj: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 424, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":425 + * + * if have_slices: + * obj = self.is_slice(value) # <<<<<<<<<<<<<< + * if obj: + * self.setitem_slice_assignment(self[index], obj) + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_obj = __pyx_t_2; + __pyx_t_2 = 0; + + /* "View.MemoryView":426 + * if have_slices: + * obj = self.is_slice(value) + * if obj: # <<<<<<<<<<<<<< + * self.setitem_slice_assignment(self[index], obj) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 426, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":427 + * obj = self.is_slice(value) + * if obj: + * self.setitem_slice_assignment(self[index], obj) # <<<<<<<<<<<<<< + * else: + * self.setitem_slice_assign_scalar(self[index], value) + */ + __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_2, __pyx_v_obj); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":426 + * if have_slices: + * obj = self.is_slice(value) + * if obj: # <<<<<<<<<<<<<< + * self.setitem_slice_assignment(self[index], obj) + * else: + */ + goto __pyx_L5; + } + + /* "View.MemoryView":429 + * self.setitem_slice_assignment(self[index], obj) + * else: + * self.setitem_slice_assign_scalar(self[index], value) # <<<<<<<<<<<<<< + * else: + * self.setitem_indexed(index, value) + */ + /*else*/ { + __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_memoryview_type))))) __PYX_ERR(1, 429, __pyx_L1_error) + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_4), __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L5:; + + /* "View.MemoryView":424 + * have_slices, index = _unellipsify(index, self.view.ndim) + * + * if have_slices: # <<<<<<<<<<<<<< + * obj = self.is_slice(value) + * if obj: + */ + goto __pyx_L4; + } + + /* "View.MemoryView":431 + * self.setitem_slice_assign_scalar(self[index], value) + * else: + * self.setitem_indexed(index, value) # <<<<<<<<<<<<<< + * + * cdef is_slice(self, obj): + */ + /*else*/ { + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 431, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L4:; + + /* "View.MemoryView":418 + * return self.convert_item_to_object(itemp) + * + * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView.memoryview.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_have_slices); + __Pyx_XDECREF(__pyx_v_obj); + __Pyx_XDECREF(__pyx_v_index); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":433 + * self.setitem_indexed(index, value) + * + * cdef is_slice(self, obj): # <<<<<<<<<<<<<< + * if not isinstance(obj, memoryview): + * try: + */ + +static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_slice", 0); + __Pyx_INCREF(__pyx_v_obj); + + /* "View.MemoryView":434 + * + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + */ + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_obj, __pyx_memoryview_type); + __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":435 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + /*try:*/ { + + /* "View.MemoryView":436 + * if not isinstance(obj, memoryview): + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< + * self.dtype_is_object) + * except TypeError: + */ + __pyx_t_6 = __Pyx_PyInt_From_int(((__pyx_v_self->flags & (~PyBUF_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 436, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "View.MemoryView":437 + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) # <<<<<<<<<<<<<< + * except TypeError: + * return None + */ + __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 437, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_7); + + /* "View.MemoryView":436 + * if not isinstance(obj, memoryview): + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< + * self.dtype_is_object) + * except TypeError: + */ + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 436, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_v_obj); + __Pyx_GIVEREF(__pyx_v_obj); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_obj); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7); + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 436, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF_SET(__pyx_v_obj, __pyx_t_7); + __pyx_t_7 = 0; + + /* "View.MemoryView":435 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + */ + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L9_try_end; + __pyx_L4_error:; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "View.MemoryView":438 + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + * except TypeError: # <<<<<<<<<<<<<< + * return None + * + */ + __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); + if (__pyx_t_9) { + __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_6) < 0) __PYX_ERR(1, 438, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_t_6); + + /* "View.MemoryView":439 + * self.dtype_is_object) + * except TypeError: + * return None # <<<<<<<<<<<<<< + * + * return obj + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L7_except_return; + } + goto __pyx_L6_except_error; + __pyx_L6_except_error:; + + /* "View.MemoryView":435 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + */ + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + goto __pyx_L1_error; + __pyx_L7_except_return:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + goto __pyx_L0; + __pyx_L9_try_end:; + } + + /* "View.MemoryView":434 + * + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + */ + } + + /* "View.MemoryView":441 + * return None + * + * return obj # <<<<<<<<<<<<<< + * + * cdef setitem_slice_assignment(self, dst, src): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_obj); + __pyx_r = __pyx_v_obj; + goto __pyx_L0; + + /* "View.MemoryView":433 + * self.setitem_indexed(index, value) + * + * cdef is_slice(self, obj): # <<<<<<<<<<<<<< + * if not isinstance(obj, memoryview): + * try: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_obj); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":443 + * return obj + * + * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice dst_slice + * cdef __Pyx_memviewslice src_slice + */ + +static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src) { + __Pyx_memviewslice __pyx_v_dst_slice; + __Pyx_memviewslice __pyx_v_src_slice; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + __Pyx_memviewslice *__pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setitem_slice_assignment", 0); + + /* "View.MemoryView":447 + * cdef __Pyx_memviewslice src_slice + * + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<< + * get_slice_from_memview(dst, &dst_slice)[0], + * src.ndim, dst.ndim, self.dtype_is_object) + */ + if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_memoryview_type))))) __PYX_ERR(1, 447, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_src), (&__pyx_v_src_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 447, __pyx_L1_error) + + /* "View.MemoryView":448 + * + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], + * get_slice_from_memview(dst, &dst_slice)[0], # <<<<<<<<<<<<<< + * src.ndim, dst.ndim, self.dtype_is_object) + * + */ + if (!(likely(((__pyx_v_dst) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_dst, __pyx_memoryview_type))))) __PYX_ERR(1, 448, __pyx_L1_error) + __pyx_t_2 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_2 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 448, __pyx_L1_error) + + /* "View.MemoryView":449 + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], + * get_slice_from_memview(dst, &dst_slice)[0], + * src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<< + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 449, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 449, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":447 + * cdef __Pyx_memviewslice src_slice + * + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<< + * get_slice_from_memview(dst, &dst_slice)[0], + * src.ndim, dst.ndim, self.dtype_is_object) + */ + __pyx_t_6 = __pyx_memoryview_copy_contents((__pyx_t_1[0]), (__pyx_t_2[0]), __pyx_t_4, __pyx_t_5, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 447, __pyx_L1_error) + + /* "View.MemoryView":443 + * return obj + * + * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice dst_slice + * cdef __Pyx_memviewslice src_slice + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assignment", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":451 + * src.ndim, dst.ndim, self.dtype_is_object) + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< + * cdef int array[128] + * cdef void *tmp = NULL + */ + +static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value) { + int __pyx_v_array[0x80]; + void *__pyx_v_tmp; + void *__pyx_v_item; + __Pyx_memviewslice *__pyx_v_dst_slice; + __Pyx_memviewslice __pyx_v_tmp_slice; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + char const *__pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 0); + + /* "View.MemoryView":453 + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): + * cdef int array[128] + * cdef void *tmp = NULL # <<<<<<<<<<<<<< + * cdef void *item + * + */ + __pyx_v_tmp = NULL; + + /* "View.MemoryView":458 + * cdef __Pyx_memviewslice *dst_slice + * cdef __Pyx_memviewslice tmp_slice + * dst_slice = get_slice_from_memview(dst, &tmp_slice) # <<<<<<<<<<<<<< + * + * if self.view.itemsize > sizeof(array): + */ + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 458, __pyx_L1_error) + __pyx_v_dst_slice = __pyx_t_1; + + /* "View.MemoryView":460 + * dst_slice = get_slice_from_memview(dst, &tmp_slice) + * + * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: + */ + __pyx_t_2 = ((((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array))) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":461 + * + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) # <<<<<<<<<<<<<< + * if tmp == NULL: + * raise MemoryError + */ + __pyx_v_tmp = PyMem_Malloc(__pyx_v_self->view.itemsize); + + /* "View.MemoryView":462 + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * item = tmp + */ + __pyx_t_2 = ((__pyx_v_tmp == NULL) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":463 + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * item = tmp + * else: + */ + PyErr_NoMemory(); __PYX_ERR(1, 463, __pyx_L1_error) + + /* "View.MemoryView":462 + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * item = tmp + */ + } + + /* "View.MemoryView":464 + * if tmp == NULL: + * raise MemoryError + * item = tmp # <<<<<<<<<<<<<< + * else: + * item = array + */ + __pyx_v_item = __pyx_v_tmp; + + /* "View.MemoryView":460 + * dst_slice = get_slice_from_memview(dst, &tmp_slice) + * + * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":466 + * item = tmp + * else: + * item = array # <<<<<<<<<<<<<< + * + * try: + */ + /*else*/ { + __pyx_v_item = ((void *)__pyx_v_array); + } + __pyx_L3:; + + /* "View.MemoryView":468 + * item = array + * + * try: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * ( item)[0] = value + */ + /*try:*/ { + + /* "View.MemoryView":469 + * + * try: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * ( item)[0] = value + * else: + */ + __pyx_t_2 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":470 + * try: + * if self.dtype_is_object: + * ( item)[0] = value # <<<<<<<<<<<<<< + * else: + * self.assign_item_from_object( item, value) + */ + (((PyObject **)__pyx_v_item)[0]) = ((PyObject *)__pyx_v_value); + + /* "View.MemoryView":469 + * + * try: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * ( item)[0] = value + * else: + */ + goto __pyx_L8; + } + + /* "View.MemoryView":472 + * ( item)[0] = value + * else: + * self.assign_item_from_object( item, value) # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, ((char *)__pyx_v_item), __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 472, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L8:; + + /* "View.MemoryView":476 + * + * + * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, + */ + __pyx_t_2 = ((__pyx_v_self->view.suboffsets != NULL) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":477 + * + * if self.view.suboffsets != NULL: + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) # <<<<<<<<<<<<<< + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, + * item, self.dtype_is_object) + */ + __pyx_t_3 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 477, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":476 + * + * + * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, + */ + } + + /* "View.MemoryView":478 + * if self.view.suboffsets != NULL: + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, # <<<<<<<<<<<<<< + * item, self.dtype_is_object) + * finally: + */ + __pyx_memoryview_slice_assign_scalar(__pyx_v_dst_slice, __pyx_v_dst->view.ndim, __pyx_v_self->view.itemsize, __pyx_v_item, __pyx_v_self->dtype_is_object); + } + + /* "View.MemoryView":481 + * item, self.dtype_is_object) + * finally: + * PyMem_Free(tmp) # <<<<<<<<<<<<<< + * + * cdef setitem_indexed(self, index, value): + */ + /*finally:*/ { + /*normal exit:*/{ + PyMem_Free(__pyx_v_tmp); + goto __pyx_L7; + } + __pyx_L6_error:; + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename; + { + PyMem_Free(__pyx_v_tmp); + } + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + } + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ErrRestore(__pyx_t_7, __pyx_t_8, __pyx_t_9); + __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; + __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_6; + goto __pyx_L1_error; + } + __pyx_L7:; + } + + /* "View.MemoryView":451 + * src.ndim, dst.ndim, self.dtype_is_object) + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< + * cdef int array[128] + * cdef void *tmp = NULL + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":483 + * PyMem_Free(tmp) + * + * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< + * cdef char *itemp = self.get_item_pointer(index) + * self.assign_item_from_object(itemp, value) + */ + +static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + char *__pyx_v_itemp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setitem_indexed", 0); + + /* "View.MemoryView":484 + * + * cdef setitem_indexed(self, index, value): + * cdef char *itemp = self.get_item_pointer(index) # <<<<<<<<<<<<<< + * self.assign_item_from_object(itemp, value) + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_index); if (unlikely(__pyx_t_1 == ((char *)NULL))) __PYX_ERR(1, 484, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_1; + + /* "View.MemoryView":485 + * cdef setitem_indexed(self, index, value): + * cdef char *itemp = self.get_item_pointer(index) + * self.assign_item_from_object(itemp, value) # <<<<<<<<<<<<<< + * + * cdef convert_item_to_object(self, char *itemp): + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 485, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":483 + * PyMem_Free(tmp) + * + * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< + * cdef char *itemp = self.get_item_pointer(index) + * self.assign_item_from_object(itemp, value) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_indexed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":487 + * self.assign_item_from_object(itemp, value) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + */ + +static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp) { + PyObject *__pyx_v_struct = NULL; + PyObject *__pyx_v_bytesitem = 0; + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; + int __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("convert_item_to_object", 0); + + /* "View.MemoryView":490 + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + * import struct # <<<<<<<<<<<<<< + * cdef bytes bytesitem + * + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_struct = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":493 + * cdef bytes bytesitem + * + * bytesitem = itemp[:self.view.itemsize] # <<<<<<<<<<<<<< + * try: + * result = struct.unpack(self.view.format, bytesitem) + */ + __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_itemp + 0, __pyx_v_self->view.itemsize - 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_bytesitem = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":494 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + /*try:*/ { + + /* "View.MemoryView":495 + * bytesitem = itemp[:self.view.itemsize] + * try: + * result = struct.unpack(self.view.format, bytesitem) # <<<<<<<<<<<<<< + * except struct.error: + * raise ValueError("Unable to convert item to object") + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_unpack); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6); + __Pyx_INCREF(__pyx_v_bytesitem); + __Pyx_GIVEREF(__pyx_v_bytesitem); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_bytesitem); + __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":494 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + */ + } + + /* "View.MemoryView":499 + * raise ValueError("Unable to convert item to object") + * else: + * if len(self.view.format) == 1: # <<<<<<<<<<<<<< + * return result[0] + * return result + */ + /*else:*/ { + __pyx_t_10 = strlen(__pyx_v_self->view.format); + __pyx_t_11 = ((__pyx_t_10 == 1) != 0); + if (__pyx_t_11) { + + /* "View.MemoryView":500 + * else: + * if len(self.view.format) == 1: + * return result[0] # <<<<<<<<<<<<<< + * return result + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_result, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 500, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L6_except_return; + + /* "View.MemoryView":499 + * raise ValueError("Unable to convert item to object") + * else: + * if len(self.view.format) == 1: # <<<<<<<<<<<<<< + * return result[0] + * return result + */ + } + + /* "View.MemoryView":501 + * if len(self.view.format) == 1: + * return result[0] + * return result # <<<<<<<<<<<<<< + * + * cdef assign_item_from_object(self, char *itemp, object value): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L6_except_return; + } + __pyx_L3_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "View.MemoryView":496 + * try: + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: # <<<<<<<<<<<<<< + * raise ValueError("Unable to convert item to object") + * else: + */ + __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_5, &__pyx_t_9); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 496, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_9); + __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_9 = 0; + if (__pyx_t_8) { + __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 496, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_1); + + /* "View.MemoryView":497 + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< + * else: + * if len(self.view.format) == 1: + */ + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 497, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(1, 497, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "View.MemoryView":494 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + */ + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L1_error; + __pyx_L6_except_return:; + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L0; + } + + /* "View.MemoryView":487 + * self.assign_item_from_object(itemp, value) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_struct); + __Pyx_XDECREF(__pyx_v_bytesitem); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":503 + * return result + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + */ + +static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { + PyObject *__pyx_v_struct = NULL; + char __pyx_v_c; + PyObject *__pyx_v_bytesvalue = 0; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + Py_ssize_t __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + char *__pyx_t_11; + char *__pyx_t_12; + char *__pyx_t_13; + char *__pyx_t_14; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("assign_item_from_object", 0); + + /* "View.MemoryView":506 + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + * import struct # <<<<<<<<<<<<<< + * cdef char c + * cdef bytes bytesvalue + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 506, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_struct = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":511 + * cdef Py_ssize_t i + * + * if isinstance(value, tuple): # <<<<<<<<<<<<<< + * bytesvalue = struct.pack(self.view.format, *value) + * else: + */ + __pyx_t_2 = PyTuple_Check(__pyx_v_value); + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "View.MemoryView":512 + * + * if isinstance(value, tuple): + * bytesvalue = struct.pack(self.view.format, *value) # <<<<<<<<<<<<<< + * else: + * bytesvalue = struct.pack(self.view.format, value) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||((void)PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 512, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":511 + * cdef Py_ssize_t i + * + * if isinstance(value, tuple): # <<<<<<<<<<<<<< + * bytesvalue = struct.pack(self.view.format, *value) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":514 + * bytesvalue = struct.pack(self.view.format, *value) + * else: + * bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<< + * + * for i, c in enumerate(bytesvalue): + */ + /*else*/ { + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_value); + __pyx_t_1 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||((void)PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 514, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + } + __pyx_L3:; + + /* "View.MemoryView":516 + * bytesvalue = struct.pack(self.view.format, value) + * + * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< + * itemp[i] = c + * + */ + __pyx_t_9 = 0; + if (unlikely(__pyx_v_bytesvalue == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable"); + __PYX_ERR(1, 516, __pyx_L1_error) + } + __Pyx_INCREF(__pyx_v_bytesvalue); + __pyx_t_10 = __pyx_v_bytesvalue; + __pyx_t_12 = PyBytes_AS_STRING(__pyx_t_10); + __pyx_t_13 = (__pyx_t_12 + PyBytes_GET_SIZE(__pyx_t_10)); + for (__pyx_t_14 = __pyx_t_12; __pyx_t_14 < __pyx_t_13; __pyx_t_14++) { + __pyx_t_11 = __pyx_t_14; + __pyx_v_c = (__pyx_t_11[0]); + + /* "View.MemoryView":517 + * + * for i, c in enumerate(bytesvalue): + * itemp[i] = c # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + __pyx_v_i = __pyx_t_9; + + /* "View.MemoryView":516 + * bytesvalue = struct.pack(self.view.format, value) + * + * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< + * itemp[i] = c + * + */ + __pyx_t_9 = (__pyx_t_9 + 1); + + /* "View.MemoryView":517 + * + * for i, c in enumerate(bytesvalue): + * itemp[i] = c # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c; + } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "View.MemoryView":503 + * return result + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("View.MemoryView.memoryview.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_struct); + __Pyx_XDECREF(__pyx_v_bytesvalue); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":520 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError("Cannot create writable memory view from read-only memoryview") + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t *__pyx_t_4; + char *__pyx_t_5; + void *__pyx_t_6; + int __pyx_t_7; + Py_ssize_t __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + if (__pyx_v_info == NULL) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + + /* "View.MemoryView":521 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + */ + __pyx_t_2 = ((__pyx_v_flags & PyBUF_WRITABLE) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_self->view.readonly != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":522 + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<< + * + * if flags & PyBUF_ND: + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 522, __pyx_L1_error) + + /* "View.MemoryView":521 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + */ + } + + /* "View.MemoryView":524 + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + * if flags & PyBUF_ND: # <<<<<<<<<<<<<< + * info.shape = self.view.shape + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":525 + * + * if flags & PyBUF_ND: + * info.shape = self.view.shape # <<<<<<<<<<<<<< + * else: + * info.shape = NULL + */ + __pyx_t_4 = __pyx_v_self->view.shape; + __pyx_v_info->shape = __pyx_t_4; + + /* "View.MemoryView":524 + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + * if flags & PyBUF_ND: # <<<<<<<<<<<<<< + * info.shape = self.view.shape + * else: + */ + goto __pyx_L6; + } + + /* "View.MemoryView":527 + * info.shape = self.view.shape + * else: + * info.shape = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_STRIDES: + */ + /*else*/ { + __pyx_v_info->shape = NULL; + } + __pyx_L6:; + + /* "View.MemoryView":529 + * info.shape = NULL + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.strides = self.view.strides + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":530 + * + * if flags & PyBUF_STRIDES: + * info.strides = self.view.strides # <<<<<<<<<<<<<< + * else: + * info.strides = NULL + */ + __pyx_t_4 = __pyx_v_self->view.strides; + __pyx_v_info->strides = __pyx_t_4; + + /* "View.MemoryView":529 + * info.shape = NULL + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.strides = self.view.strides + * else: + */ + goto __pyx_L7; + } + + /* "View.MemoryView":532 + * info.strides = self.view.strides + * else: + * info.strides = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_INDIRECT: + */ + /*else*/ { + __pyx_v_info->strides = NULL; + } + __pyx_L7:; + + /* "View.MemoryView":534 + * info.strides = NULL + * + * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< + * info.suboffsets = self.view.suboffsets + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_INDIRECT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":535 + * + * if flags & PyBUF_INDIRECT: + * info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<< + * else: + * info.suboffsets = NULL + */ + __pyx_t_4 = __pyx_v_self->view.suboffsets; + __pyx_v_info->suboffsets = __pyx_t_4; + + /* "View.MemoryView":534 + * info.strides = NULL + * + * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< + * info.suboffsets = self.view.suboffsets + * else: + */ + goto __pyx_L8; + } + + /* "View.MemoryView":537 + * info.suboffsets = self.view.suboffsets + * else: + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + /*else*/ { + __pyx_v_info->suboffsets = NULL; + } + __pyx_L8:; + + /* "View.MemoryView":539 + * info.suboffsets = NULL + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.view.format + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":540 + * + * if flags & PyBUF_FORMAT: + * info.format = self.view.format # <<<<<<<<<<<<<< + * else: + * info.format = NULL + */ + __pyx_t_5 = __pyx_v_self->view.format; + __pyx_v_info->format = __pyx_t_5; + + /* "View.MemoryView":539 + * info.suboffsets = NULL + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.view.format + * else: + */ + goto __pyx_L9; + } + + /* "View.MemoryView":542 + * info.format = self.view.format + * else: + * info.format = NULL # <<<<<<<<<<<<<< + * + * info.buf = self.view.buf + */ + /*else*/ { + __pyx_v_info->format = NULL; + } + __pyx_L9:; + + /* "View.MemoryView":544 + * info.format = NULL + * + * info.buf = self.view.buf # <<<<<<<<<<<<<< + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize + */ + __pyx_t_6 = __pyx_v_self->view.buf; + __pyx_v_info->buf = __pyx_t_6; + + /* "View.MemoryView":545 + * + * info.buf = self.view.buf + * info.ndim = self.view.ndim # <<<<<<<<<<<<<< + * info.itemsize = self.view.itemsize + * info.len = self.view.len + */ + __pyx_t_7 = __pyx_v_self->view.ndim; + __pyx_v_info->ndim = __pyx_t_7; + + /* "View.MemoryView":546 + * info.buf = self.view.buf + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize # <<<<<<<<<<<<<< + * info.len = self.view.len + * info.readonly = self.view.readonly + */ + __pyx_t_8 = __pyx_v_self->view.itemsize; + __pyx_v_info->itemsize = __pyx_t_8; + + /* "View.MemoryView":547 + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize + * info.len = self.view.len # <<<<<<<<<<<<<< + * info.readonly = self.view.readonly + * info.obj = self + */ + __pyx_t_8 = __pyx_v_self->view.len; + __pyx_v_info->len = __pyx_t_8; + + /* "View.MemoryView":548 + * info.itemsize = self.view.itemsize + * info.len = self.view.len + * info.readonly = self.view.readonly # <<<<<<<<<<<<<< + * info.obj = self + * + */ + __pyx_t_1 = __pyx_v_self->view.readonly; + __pyx_v_info->readonly = __pyx_t_1; + + /* "View.MemoryView":549 + * info.len = self.view.len + * info.readonly = self.view.readonly + * info.obj = self # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") + */ + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + + /* "View.MemoryView":520 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError("Cannot create writable memory view from read-only memoryview") + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":555 + * + * @property + * def T(self): # <<<<<<<<<<<<<< + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":556 + * @property + * def T(self): + * cdef _memoryviewslice result = memoryview_copy(self) # <<<<<<<<<<<<<< + * transpose_memslice(&result.from_slice) + * return result + */ + __pyx_t_1 = __pyx_memoryview_copy_object(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 556, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_memoryviewslice_type))))) __PYX_ERR(1, 556, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":557 + * def T(self): + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_2 = __pyx_memslice_transpose((&__pyx_v_result->from_slice)); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 557, __pyx_L1_error) + + /* "View.MemoryView":558 + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) + * return result # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "View.MemoryView":555 + * + * @property + * def T(self): # <<<<<<<<<<<<<< + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.T.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":561 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.obj + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":562 + * @property + * def base(self): + * return self.obj # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->obj); + __pyx_r = __pyx_v_self->obj; + goto __pyx_L0; + + /* "View.MemoryView":561 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.obj + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":565 + * + * @property + * def shape(self): # <<<<<<<<<<<<<< + * return tuple([length for length in self.view.shape[:self.view.ndim]]) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_v_length; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":566 + * @property + * def shape(self): + * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); + for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { + __pyx_t_2 = __pyx_t_4; + __pyx_v_length = (__pyx_t_2[0]); + __pyx_t_5 = PyInt_FromSsize_t(__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "View.MemoryView":565 + * + * @property + * def shape(self): # <<<<<<<<<<<<<< + * return tuple([length for length in self.view.shape[:self.view.ndim]]) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.shape.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":569 + * + * @property + * def strides(self): # <<<<<<<<<<<<<< + * if self.view.strides == NULL: + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_v_stride; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":570 + * @property + * def strides(self): + * if self.view.strides == NULL: # <<<<<<<<<<<<<< + * + * raise ValueError("Buffer view does not expose strides") + */ + __pyx_t_1 = ((__pyx_v_self->view.strides == NULL) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":572 + * if self.view.strides == NULL: + * + * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 572, __pyx_L1_error) + + /* "View.MemoryView":570 + * @property + * def strides(self): + * if self.view.strides == NULL: # <<<<<<<<<<<<<< + * + * raise ValueError("Buffer view does not expose strides") + */ + } + + /* "View.MemoryView":574 + * raise ValueError("Buffer view does not expose strides") + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = (__pyx_v_self->view.strides + __pyx_v_self->view.ndim); + for (__pyx_t_5 = __pyx_v_self->view.strides; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { + __pyx_t_3 = __pyx_t_5; + __pyx_v_stride = (__pyx_t_3[0]); + __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; + goto __pyx_L0; + + /* "View.MemoryView":569 + * + * @property + * def strides(self): # <<<<<<<<<<<<<< + * if self.view.strides == NULL: + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView.memoryview.strides.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":577 + * + * @property + * def suboffsets(self): # <<<<<<<<<<<<<< + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_v_suboffset; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + Py_ssize_t *__pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":578 + * @property + * def suboffsets(self): + * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< + * return (-1,) * self.view.ndim + * + */ + __pyx_t_1 = ((__pyx_v_self->view.suboffsets == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":579 + * def suboffsets(self): + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_tuple__17, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":578 + * @property + * def suboffsets(self): + * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< + * return (-1,) * self.view.ndim + * + */ + } + + /* "View.MemoryView":581 + * return (-1,) * self.view.ndim + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim); + for (__pyx_t_6 = __pyx_v_self->view.suboffsets; __pyx_t_6 < __pyx_t_5; __pyx_t_6++) { + __pyx_t_4 = __pyx_t_6; + __pyx_v_suboffset = (__pyx_t_4[0]); + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_suboffset); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_2))) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = PyList_AsTuple(((PyObject*)__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":577 + * + * @property + * def suboffsets(self): # <<<<<<<<<<<<<< + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.suboffsets.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":584 + * + * @property + * def ndim(self): # <<<<<<<<<<<<<< + * return self.view.ndim + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":585 + * @property + * def ndim(self): + * return self.view.ndim # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 585, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":584 + * + * @property + * def ndim(self): # <<<<<<<<<<<<<< + * return self.view.ndim + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.ndim.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":588 + * + * @property + * def itemsize(self): # <<<<<<<<<<<<<< + * return self.view.itemsize + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":589 + * @property + * def itemsize(self): + * return self.view.itemsize # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":588 + * + * @property + * def itemsize(self): # <<<<<<<<<<<<<< + * return self.view.itemsize + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.itemsize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":592 + * + * @property + * def nbytes(self): # <<<<<<<<<<<<<< + * return self.size * self.view.itemsize + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":593 + * @property + * def nbytes(self): + * return self.size * self.view.itemsize # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":592 + * + * @property + * def nbytes(self): # <<<<<<<<<<<<<< + * return self.size * self.view.itemsize + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.nbytes.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":596 + * + * @property + * def size(self): # <<<<<<<<<<<<<< + * if self._size is None: + * result = 1 + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_v_length = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":597 + * @property + * def size(self): + * if self._size is None: # <<<<<<<<<<<<<< + * result = 1 + * + */ + __pyx_t_1 = (__pyx_v_self->_size == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":598 + * def size(self): + * if self._size is None: + * result = 1 # <<<<<<<<<<<<<< + * + * for length in self.view.shape[:self.view.ndim]: + */ + __Pyx_INCREF(__pyx_int_1); + __pyx_v_result = __pyx_int_1; + + /* "View.MemoryView":600 + * result = 1 + * + * for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<< + * result *= length + * + */ + __pyx_t_4 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); + for (__pyx_t_5 = __pyx_v_self->view.shape; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { + __pyx_t_3 = __pyx_t_5; + __pyx_t_6 = PyInt_FromSsize_t((__pyx_t_3[0])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_6); + __pyx_t_6 = 0; + + /* "View.MemoryView":601 + * + * for length in self.view.shape[:self.view.ndim]: + * result *= length # <<<<<<<<<<<<<< + * + * self._size = result + */ + __pyx_t_6 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_6); + __pyx_t_6 = 0; + } + + /* "View.MemoryView":603 + * result *= length + * + * self._size = result # <<<<<<<<<<<<<< + * + * return self._size + */ + __Pyx_INCREF(__pyx_v_result); + __Pyx_GIVEREF(__pyx_v_result); + __Pyx_GOTREF(__pyx_v_self->_size); + __Pyx_DECREF(__pyx_v_self->_size); + __pyx_v_self->_size = __pyx_v_result; + + /* "View.MemoryView":597 + * @property + * def size(self): + * if self._size is None: # <<<<<<<<<<<<<< + * result = 1 + * + */ + } + + /* "View.MemoryView":605 + * self._size = result + * + * return self._size # <<<<<<<<<<<<<< + * + * def __len__(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_size); + __pyx_r = __pyx_v_self->_size; + goto __pyx_L0; + + /* "View.MemoryView":596 + * + * @property + * def size(self): # <<<<<<<<<<<<<< + * if self._size is None: + * result = 1 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView.memoryview.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_length); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":607 + * return self._size + * + * def __len__(self): # <<<<<<<<<<<<<< + * if self.view.ndim >= 1: + * return self.view.shape[0] + */ + +/* Python wrapper */ +static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self); /*proto*/ +static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__len__", 0); + + /* "View.MemoryView":608 + * + * def __len__(self): + * if self.view.ndim >= 1: # <<<<<<<<<<<<<< + * return self.view.shape[0] + * + */ + __pyx_t_1 = ((__pyx_v_self->view.ndim >= 1) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":609 + * def __len__(self): + * if self.view.ndim >= 1: + * return self.view.shape[0] # <<<<<<<<<<<<<< + * + * return 0 + */ + __pyx_r = (__pyx_v_self->view.shape[0]); + goto __pyx_L0; + + /* "View.MemoryView":608 + * + * def __len__(self): + * if self.view.ndim >= 1: # <<<<<<<<<<<<<< + * return self.view.shape[0] + * + */ + } + + /* "View.MemoryView":611 + * return self.view.shape[0] + * + * return 0 # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":607 + * return self._size + * + * def __len__(self): # <<<<<<<<<<<<<< + * if self.view.ndim >= 1: + * return self.view.shape[0] + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":613 + * return 0 + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__, + * id(self)) + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "View.MemoryView":614 + * + * def __repr__(self): + * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< + * id(self)) + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":615 + * def __repr__(self): + * return "" % (self.base.__class__.__name__, + * id(self)) # <<<<<<<<<<<<<< + * + * def __str__(self): + */ + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "View.MemoryView":614 + * + * def __repr__(self): + * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< + * id(self)) + * + */ + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":613 + * return 0 + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__, + * id(self)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":617 + * id(self)) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__,) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__str__", 0); + + /* "View.MemoryView":618 + * + * def __str__(self): + * return "" % (self.base.__class__.__name__,) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_object, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":617 + * id(self)) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__,) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":621 + * + * + * def is_c_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_c_contig (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice *__pyx_v_mslice; + __Pyx_memviewslice __pyx_v_tmp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_c_contig", 0); + + /* "View.MemoryView":624 + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< + * return slice_is_contig(mslice[0], 'C', self.view.ndim) + * + */ + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 624, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":625 + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) + * return slice_is_contig(mslice[0], 'C', self.view.ndim) # <<<<<<<<<<<<<< + * + * def is_f_contig(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'C', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":621 + * + * + * def is_c_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.is_c_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":627 + * return slice_is_contig(mslice[0], 'C', self.view.ndim) + * + * def is_f_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_f_contig (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice *__pyx_v_mslice; + __Pyx_memviewslice __pyx_v_tmp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_f_contig", 0); + + /* "View.MemoryView":630 + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< + * return slice_is_contig(mslice[0], 'F', self.view.ndim) + * + */ + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 630, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":631 + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) + * return slice_is_contig(mslice[0], 'F', self.view.ndim) # <<<<<<<<<<<<<< + * + * def copy(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'F', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":627 + * return slice_is_contig(mslice[0], 'C', self.view.ndim) + * + * def is_f_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.is_f_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":633 + * return slice_is_contig(mslice[0], 'F', self.view.ndim) + * + * def copy(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice mslice + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice __pyx_v_mslice; + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("copy", 0); + + /* "View.MemoryView":635 + * def copy(self): + * cdef __Pyx_memviewslice mslice + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS # <<<<<<<<<<<<<< + * + * slice_copy(self, &mslice) + */ + __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_F_CONTIGUOUS)); + + /* "View.MemoryView":637 + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS + * + * slice_copy(self, &mslice) # <<<<<<<<<<<<<< + * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, + * self.view.itemsize, + */ + __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_mslice)); + + /* "View.MemoryView":638 + * + * slice_copy(self, &mslice) + * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, # <<<<<<<<<<<<<< + * self.view.itemsize, + * flags|PyBUF_C_CONTIGUOUS, + */ + __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_mslice), ((char *)"c"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_C_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 638, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":643 + * self.dtype_is_object) + * + * return memoryview_copy_from_slice(self, &mslice) # <<<<<<<<<<<<<< + * + * def copy_fortran(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_mslice)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 643, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":633 + * return slice_is_contig(mslice[0], 'F', self.view.ndim) + * + * def copy(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice mslice + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":645 + * return memoryview_copy_from_slice(self, &mslice) + * + * def copy_fortran(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice src, dst + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy_fortran (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice __pyx_v_src; + __Pyx_memviewslice __pyx_v_dst; + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("copy_fortran", 0); + + /* "View.MemoryView":647 + * def copy_fortran(self): + * cdef __Pyx_memviewslice src, dst + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS # <<<<<<<<<<<<<< + * + * slice_copy(self, &src) + */ + __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_C_CONTIGUOUS)); + + /* "View.MemoryView":649 + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS + * + * slice_copy(self, &src) # <<<<<<<<<<<<<< + * dst = slice_copy_contig(&src, "fortran", self.view.ndim, + * self.view.itemsize, + */ + __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_src)); + + /* "View.MemoryView":650 + * + * slice_copy(self, &src) + * dst = slice_copy_contig(&src, "fortran", self.view.ndim, # <<<<<<<<<<<<<< + * self.view.itemsize, + * flags|PyBUF_F_CONTIGUOUS, + */ + __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_src), ((char *)"fortran"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_F_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 650, __pyx_L1_error) + __pyx_v_dst = __pyx_t_1; + + /* "View.MemoryView":655 + * self.dtype_is_object) + * + * return memoryview_copy_from_slice(self, &dst) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_dst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 655, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":645 + * return memoryview_copy_from_slice(self, &mslice) + * + * def copy_fortran(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice src, dst + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.copy_fortran", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_memoryview___reduce_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__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.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__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.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":659 + * + * @cname('__pyx_memoryview_new') + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo + */ + +static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, int __pyx_v_dtype_is_object, __Pyx_TypeInfo *__pyx_v_typeinfo) { + struct __pyx_memoryview_obj *__pyx_v_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_cwrapper", 0); + + /* "View.MemoryView":660 + * @cname('__pyx_memoryview_new') + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): + * cdef memoryview result = memoryview(o, flags, dtype_is_object) # <<<<<<<<<<<<<< + * result.typeinfo = typeinfo + * return result + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_o); + __Pyx_GIVEREF(__pyx_v_o); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_o); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = ((struct __pyx_memoryview_obj *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":661 + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_v_result->typeinfo = __pyx_v_typeinfo; + + /* "View.MemoryView":662 + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo + * return result # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_check') + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "View.MemoryView":659 + * + * @cname('__pyx_memoryview_new') + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":665 + * + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< + * return isinstance(o, memoryview) + * + */ + +static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("memoryview_check", 0); + + /* "View.MemoryView":666 + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): + * return isinstance(o, memoryview) # <<<<<<<<<<<<<< + * + * cdef tuple _unellipsify(object index, int ndim): + */ + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_o, __pyx_memoryview_type); + __pyx_r = __pyx_t_1; + goto __pyx_L0; + + /* "View.MemoryView":665 + * + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< + * return isinstance(o, memoryview) + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":668 + * return isinstance(o, memoryview) + * + * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< + * """ + * Replace all ellipses with full slices and fill incomplete indices with + */ + +static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { + PyObject *__pyx_v_tup = NULL; + PyObject *__pyx_v_result = NULL; + int __pyx_v_have_slices; + int __pyx_v_seen_ellipsis; + CYTHON_UNUSED PyObject *__pyx_v_idx = NULL; + PyObject *__pyx_v_item = NULL; + Py_ssize_t __pyx_v_nslices; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + PyObject *__pyx_t_7 = NULL; + Py_ssize_t __pyx_t_8; + int __pyx_t_9; + int __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_unellipsify", 0); + + /* "View.MemoryView":673 + * full slices. + * """ + * if not isinstance(index, tuple): # <<<<<<<<<<<<<< + * tup = (index,) + * else: + */ + __pyx_t_1 = PyTuple_Check(__pyx_v_index); + __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":674 + * """ + * if not isinstance(index, tuple): + * tup = (index,) # <<<<<<<<<<<<<< + * else: + * tup = index + */ + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 674, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_index); + __Pyx_GIVEREF(__pyx_v_index); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_index); + __pyx_v_tup = __pyx_t_3; + __pyx_t_3 = 0; + + /* "View.MemoryView":673 + * full slices. + * """ + * if not isinstance(index, tuple): # <<<<<<<<<<<<<< + * tup = (index,) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":676 + * tup = (index,) + * else: + * tup = index # <<<<<<<<<<<<<< + * + * result = [] + */ + /*else*/ { + __Pyx_INCREF(__pyx_v_index); + __pyx_v_tup = __pyx_v_index; + } + __pyx_L3:; + + /* "View.MemoryView":678 + * tup = index + * + * result = [] # <<<<<<<<<<<<<< + * have_slices = False + * seen_ellipsis = False + */ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 678, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_result = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":679 + * + * result = [] + * have_slices = False # <<<<<<<<<<<<<< + * seen_ellipsis = False + * for idx, item in enumerate(tup): + */ + __pyx_v_have_slices = 0; + + /* "View.MemoryView":680 + * result = [] + * have_slices = False + * seen_ellipsis = False # <<<<<<<<<<<<<< + * for idx, item in enumerate(tup): + * if item is Ellipsis: + */ + __pyx_v_seen_ellipsis = 0; + + /* "View.MemoryView":681 + * have_slices = False + * seen_ellipsis = False + * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< + * if item is Ellipsis: + * if not seen_ellipsis: + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_3 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_tup)) || PyTuple_CheckExact(__pyx_v_tup)) { + __pyx_t_4 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_tup); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 681, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_4))) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 681, __pyx_L1_error) + #else + __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } else { + if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 681, __pyx_L1_error) + #else + __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } + } else { + __pyx_t_7 = __pyx_t_6(__pyx_t_4); + if (unlikely(!__pyx_t_7)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 681, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_7); + } + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_3); + __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); + __pyx_t_3 = __pyx_t_7; + __pyx_t_7 = 0; + + /* "View.MemoryView":682 + * seen_ellipsis = False + * for idx, item in enumerate(tup): + * if item is Ellipsis: # <<<<<<<<<<<<<< + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + */ + __pyx_t_2 = (__pyx_v_item == __pyx_builtin_Ellipsis); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":683 + * for idx, item in enumerate(tup): + * if item is Ellipsis: + * if not seen_ellipsis: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True + */ + __pyx_t_1 = ((!(__pyx_v_seen_ellipsis != 0)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":684 + * if item is Ellipsis: + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<< + * seen_ellipsis = True + * else: + */ + __pyx_t_8 = PyObject_Length(__pyx_v_tup); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(1, 684, __pyx_L1_error) + __pyx_t_7 = PyList_New(1 * ((((__pyx_v_ndim - __pyx_t_8) + 1)<0) ? 0:((__pyx_v_ndim - __pyx_t_8) + 1))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 684, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < ((__pyx_v_ndim - __pyx_t_8) + 1); __pyx_temp++) { + __Pyx_INCREF(__pyx_slice__20); + __Pyx_GIVEREF(__pyx_slice__20); + PyList_SET_ITEM(__pyx_t_7, __pyx_temp, __pyx_slice__20); + } + } + __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_7); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 684, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "View.MemoryView":685 + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True # <<<<<<<<<<<<<< + * else: + * result.append(slice(None)) + */ + __pyx_v_seen_ellipsis = 1; + + /* "View.MemoryView":683 + * for idx, item in enumerate(tup): + * if item is Ellipsis: + * if not seen_ellipsis: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True + */ + goto __pyx_L7; + } + + /* "View.MemoryView":687 + * seen_ellipsis = True + * else: + * result.append(slice(None)) # <<<<<<<<<<<<<< + * have_slices = True + * else: + */ + /*else*/ { + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_slice__20); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 687, __pyx_L1_error) + } + __pyx_L7:; + + /* "View.MemoryView":688 + * else: + * result.append(slice(None)) + * have_slices = True # <<<<<<<<<<<<<< + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): + */ + __pyx_v_have_slices = 1; + + /* "View.MemoryView":682 + * seen_ellipsis = False + * for idx, item in enumerate(tup): + * if item is Ellipsis: # <<<<<<<<<<<<<< + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + */ + goto __pyx_L6; + } + + /* "View.MemoryView":690 + * have_slices = True + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + */ + /*else*/ { + __pyx_t_2 = PySlice_Check(__pyx_v_item); + __pyx_t_10 = ((!(__pyx_t_2 != 0)) != 0); + if (__pyx_t_10) { + } else { + __pyx_t_1 = __pyx_t_10; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_10 = ((!(PyIndex_Check(__pyx_v_item) != 0)) != 0); + __pyx_t_1 = __pyx_t_10; + __pyx_L9_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":691 + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): + * raise TypeError("Cannot index with type '%s'" % type(item)) # <<<<<<<<<<<<<< + * + * have_slices = have_slices or isinstance(item, slice) + */ + __pyx_t_7 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Cannot_index_with_type_s, ((PyObject *)Py_TYPE(__pyx_v_item))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_11, 0, 0, 0); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __PYX_ERR(1, 691, __pyx_L1_error) + + /* "View.MemoryView":690 + * have_slices = True + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + */ + } + + /* "View.MemoryView":693 + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + * have_slices = have_slices or isinstance(item, slice) # <<<<<<<<<<<<<< + * result.append(item) + * + */ + __pyx_t_10 = (__pyx_v_have_slices != 0); + if (!__pyx_t_10) { + } else { + __pyx_t_1 = __pyx_t_10; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_10 = PySlice_Check(__pyx_v_item); + __pyx_t_2 = (__pyx_t_10 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L11_bool_binop_done:; + __pyx_v_have_slices = __pyx_t_1; + + /* "View.MemoryView":694 + * + * have_slices = have_slices or isinstance(item, slice) + * result.append(item) # <<<<<<<<<<<<<< + * + * nslices = ndim - len(result) + */ + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_v_item); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 694, __pyx_L1_error) + } + __pyx_L6:; + + /* "View.MemoryView":681 + * have_slices = False + * seen_ellipsis = False + * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< + * if item is Ellipsis: + * if not seen_ellipsis: + */ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":696 + * result.append(item) + * + * nslices = ndim - len(result) # <<<<<<<<<<<<<< + * if nslices: + * result.extend([slice(None)] * nslices) + */ + __pyx_t_5 = PyList_GET_SIZE(__pyx_v_result); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 696, __pyx_L1_error) + __pyx_v_nslices = (__pyx_v_ndim - __pyx_t_5); + + /* "View.MemoryView":697 + * + * nslices = ndim - len(result) + * if nslices: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * nslices) + * + */ + __pyx_t_1 = (__pyx_v_nslices != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":698 + * nslices = ndim - len(result) + * if nslices: + * result.extend([slice(None)] * nslices) # <<<<<<<<<<<<<< + * + * return have_slices or nslices, tuple(result) + */ + __pyx_t_3 = PyList_New(1 * ((__pyx_v_nslices<0) ? 0:__pyx_v_nslices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 698, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < __pyx_v_nslices; __pyx_temp++) { + __Pyx_INCREF(__pyx_slice__20); + __Pyx_GIVEREF(__pyx_slice__20); + PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_slice__20); + } + } + __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 698, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":697 + * + * nslices = ndim - len(result) + * if nslices: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * nslices) + * + */ + } + + /* "View.MemoryView":700 + * result.extend([slice(None)] * nslices) + * + * return have_slices or nslices, tuple(result) # <<<<<<<<<<<<<< + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + */ + __Pyx_XDECREF(__pyx_r); + if (!__pyx_v_have_slices) { + } else { + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L14_bool_binop_done; + } + __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_L14_bool_binop_done:; + __pyx_t_4 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_4); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_r = ((PyObject*)__pyx_t_11); + __pyx_t_11 = 0; + goto __pyx_L0; + + /* "View.MemoryView":668 + * return isinstance(o, memoryview) + * + * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< + * """ + * Replace all ellipses with full slices and fill incomplete indices with + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("View.MemoryView._unellipsify", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_tup); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_idx); + __Pyx_XDECREF(__pyx_v_item); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":702 + * return have_slices or nslices, tuple(result) + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + */ + +static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __pyx_v_ndim) { + Py_ssize_t __pyx_v_suboffset; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t *__pyx_t_1; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("assert_direct_dimensions", 0); + + /* "View.MemoryView":703 + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * for suboffset in suboffsets[:ndim]: # <<<<<<<<<<<<<< + * if suboffset >= 0: + * raise ValueError("Indirect dimensions not supported") + */ + __pyx_t_2 = (__pyx_v_suboffsets + __pyx_v_ndim); + for (__pyx_t_3 = __pyx_v_suboffsets; __pyx_t_3 < __pyx_t_2; __pyx_t_3++) { + __pyx_t_1 = __pyx_t_3; + __pyx_v_suboffset = (__pyx_t_1[0]); + + /* "View.MemoryView":704 + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * raise ValueError("Indirect dimensions not supported") + * + */ + __pyx_t_4 = ((__pyx_v_suboffset >= 0) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":705 + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + * raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(1, 705, __pyx_L1_error) + + /* "View.MemoryView":704 + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * raise ValueError("Indirect dimensions not supported") + * + */ + } + } + + /* "View.MemoryView":702 + * return have_slices or nslices, tuple(result) + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.assert_direct_dimensions", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":712 + * + * @cname('__pyx_memview_slice') + * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< + * cdef int new_ndim = 0, suboffset_dim = -1, dim + * cdef bint negative_step + */ + +static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *__pyx_v_memview, PyObject *__pyx_v_indices) { + int __pyx_v_new_ndim; + int __pyx_v_suboffset_dim; + int __pyx_v_dim; + __Pyx_memviewslice __pyx_v_src; + __Pyx_memviewslice __pyx_v_dst; + __Pyx_memviewslice *__pyx_v_p_src; + struct __pyx_memoryviewslice_obj *__pyx_v_memviewsliceobj = 0; + __Pyx_memviewslice *__pyx_v_p_dst; + int *__pyx_v_p_suboffset_dim; + Py_ssize_t __pyx_v_start; + Py_ssize_t __pyx_v_stop; + Py_ssize_t __pyx_v_step; + int __pyx_v_have_start; + int __pyx_v_have_stop; + int __pyx_v_have_step; + PyObject *__pyx_v_index = NULL; + struct __pyx_memoryview_obj *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + struct __pyx_memoryview_obj *__pyx_t_4; + char *__pyx_t_5; + int __pyx_t_6; + Py_ssize_t __pyx_t_7; + PyObject *(*__pyx_t_8)(PyObject *); + PyObject *__pyx_t_9 = NULL; + Py_ssize_t __pyx_t_10; + int __pyx_t_11; + Py_ssize_t __pyx_t_12; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memview_slice", 0); + + /* "View.MemoryView":713 + * @cname('__pyx_memview_slice') + * cdef memoryview memview_slice(memoryview memview, object indices): + * cdef int new_ndim = 0, suboffset_dim = -1, dim # <<<<<<<<<<<<<< + * cdef bint negative_step + * cdef __Pyx_memviewslice src, dst + */ + __pyx_v_new_ndim = 0; + __pyx_v_suboffset_dim = -1; + + /* "View.MemoryView":720 + * + * + * memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<< + * + * cdef _memoryviewslice memviewsliceobj + */ + (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst)))); + + /* "View.MemoryView":724 + * cdef _memoryviewslice memviewsliceobj + * + * assert memview.view.ndim > 0 # <<<<<<<<<<<<<< + * + * if isinstance(memview, _memoryviewslice): + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!((__pyx_v_memview->view.ndim > 0) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + __PYX_ERR(1, 724, __pyx_L1_error) + } + } + #endif + + /* "View.MemoryView":726 + * assert memview.view.ndim > 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":727 + * + * if isinstance(memview, _memoryviewslice): + * memviewsliceobj = memview # <<<<<<<<<<<<<< + * p_src = &memviewsliceobj.from_slice + * else: + */ + if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 727, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_v_memview); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":728 + * if isinstance(memview, _memoryviewslice): + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice # <<<<<<<<<<<<<< + * else: + * slice_copy(memview, &src) + */ + __pyx_v_p_src = (&__pyx_v_memviewsliceobj->from_slice); + + /* "View.MemoryView":726 + * assert memview.view.ndim > 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice + */ + goto __pyx_L3; + } + + /* "View.MemoryView":730 + * p_src = &memviewsliceobj.from_slice + * else: + * slice_copy(memview, &src) # <<<<<<<<<<<<<< + * p_src = &src + * + */ + /*else*/ { + __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_src)); + + /* "View.MemoryView":731 + * else: + * slice_copy(memview, &src) + * p_src = &src # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_p_src = (&__pyx_v_src); + } + __pyx_L3:; + + /* "View.MemoryView":737 + * + * + * dst.memview = p_src.memview # <<<<<<<<<<<<<< + * dst.data = p_src.data + * + */ + __pyx_t_4 = __pyx_v_p_src->memview; + __pyx_v_dst.memview = __pyx_t_4; + + /* "View.MemoryView":738 + * + * dst.memview = p_src.memview + * dst.data = p_src.data # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __pyx_v_p_src->data; + __pyx_v_dst.data = __pyx_t_5; + + /* "View.MemoryView":743 + * + * + * cdef __Pyx_memviewslice *p_dst = &dst # <<<<<<<<<<<<<< + * cdef int *p_suboffset_dim = &suboffset_dim + * cdef Py_ssize_t start, stop, step + */ + __pyx_v_p_dst = (&__pyx_v_dst); + + /* "View.MemoryView":744 + * + * cdef __Pyx_memviewslice *p_dst = &dst + * cdef int *p_suboffset_dim = &suboffset_dim # <<<<<<<<<<<<<< + * cdef Py_ssize_t start, stop, step + * cdef bint have_start, have_stop, have_step + */ + __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim); + + /* "View.MemoryView":748 + * cdef bint have_start, have_stop, have_step + * + * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< + * if PyIndex_Check(index): + * slice_memviewslice( + */ + __pyx_t_6 = 0; + if (likely(PyList_CheckExact(__pyx_v_indices)) || PyTuple_CheckExact(__pyx_v_indices)) { + __pyx_t_3 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_3); __pyx_t_7 = 0; + __pyx_t_8 = NULL; + } else { + __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 748, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_8)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_9 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(1, 748, __pyx_L1_error) + #else + __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + } else { + if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(1, 748, __pyx_L1_error) + #else + __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + } + } else { + __pyx_t_9 = __pyx_t_8(__pyx_t_3); + if (unlikely(!__pyx_t_9)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 748, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_9); + } + __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_v_dim = __pyx_t_6; + __pyx_t_6 = (__pyx_t_6 + 1); + + /* "View.MemoryView":749 + * + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): # <<<<<<<<<<<<<< + * slice_memviewslice( + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + */ + __pyx_t_2 = (PyIndex_Check(__pyx_v_index) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":753 + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + * dim, new_ndim, p_suboffset_dim, + * index, 0, 0, # start, stop, step # <<<<<<<<<<<<<< + * 0, 0, 0, # have_{start,stop,step} + * False) + */ + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 753, __pyx_L1_error) + + /* "View.MemoryView":750 + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): + * slice_memviewslice( # <<<<<<<<<<<<<< + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + * dim, new_ndim, p_suboffset_dim, + */ + __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_t_10, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 750, __pyx_L1_error) + + /* "View.MemoryView":749 + * + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): # <<<<<<<<<<<<<< + * slice_memviewslice( + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + */ + goto __pyx_L6; + } + + /* "View.MemoryView":756 + * 0, 0, 0, # have_{start,stop,step} + * False) + * elif index is None: # <<<<<<<<<<<<<< + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 + */ + __pyx_t_2 = (__pyx_v_index == Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":757 + * False) + * elif index is None: + * p_dst.shape[new_ndim] = 1 # <<<<<<<<<<<<<< + * p_dst.strides[new_ndim] = 0 + * p_dst.suboffsets[new_ndim] = -1 + */ + (__pyx_v_p_dst->shape[__pyx_v_new_ndim]) = 1; + + /* "View.MemoryView":758 + * elif index is None: + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 # <<<<<<<<<<<<<< + * p_dst.suboffsets[new_ndim] = -1 + * new_ndim += 1 + */ + (__pyx_v_p_dst->strides[__pyx_v_new_ndim]) = 0; + + /* "View.MemoryView":759 + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 + * p_dst.suboffsets[new_ndim] = -1 # <<<<<<<<<<<<<< + * new_ndim += 1 + * else: + */ + (__pyx_v_p_dst->suboffsets[__pyx_v_new_ndim]) = -1L; + + /* "View.MemoryView":760 + * p_dst.strides[new_ndim] = 0 + * p_dst.suboffsets[new_ndim] = -1 + * new_ndim += 1 # <<<<<<<<<<<<<< + * else: + * start = index.start or 0 + */ + __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); + + /* "View.MemoryView":756 + * 0, 0, 0, # have_{start,stop,step} + * False) + * elif index is None: # <<<<<<<<<<<<<< + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 + */ + goto __pyx_L6; + } + + /* "View.MemoryView":762 + * new_ndim += 1 + * else: + * start = index.start or 0 # <<<<<<<<<<<<<< + * stop = index.stop or 0 + * step = index.step or 0 + */ + /*else*/ { + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 762, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 762, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 762, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L7_bool_binop_done:; + __pyx_v_start = __pyx_t_10; + + /* "View.MemoryView":763 + * else: + * start = index.start or 0 + * stop = index.stop or 0 # <<<<<<<<<<<<<< + * step = index.step or 0 + * + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 763, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 763, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 763, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L9_bool_binop_done:; + __pyx_v_stop = __pyx_t_10; + + /* "View.MemoryView":764 + * start = index.start or 0 + * stop = index.stop or 0 + * step = index.step or 0 # <<<<<<<<<<<<<< + * + * have_start = index.start is not None + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 764, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 764, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 764, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L11_bool_binop_done:; + __pyx_v_step = __pyx_t_10; + + /* "View.MemoryView":766 + * step = index.step or 0 + * + * have_start = index.start is not None # <<<<<<<<<<<<<< + * have_stop = index.stop is not None + * have_step = index.step is not None + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 766, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_have_start = __pyx_t_1; + + /* "View.MemoryView":767 + * + * have_start = index.start is not None + * have_stop = index.stop is not None # <<<<<<<<<<<<<< + * have_step = index.step is not None + * + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 767, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_have_stop = __pyx_t_1; + + /* "View.MemoryView":768 + * have_start = index.start is not None + * have_stop = index.stop is not None + * have_step = index.step is not None # <<<<<<<<<<<<<< + * + * slice_memviewslice( + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 768, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_have_step = __pyx_t_1; + + /* "View.MemoryView":770 + * have_step = index.step is not None + * + * slice_memviewslice( # <<<<<<<<<<<<<< + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + * dim, new_ndim, p_suboffset_dim, + */ + __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_start, __pyx_v_stop, __pyx_v_step, __pyx_v_have_start, __pyx_v_have_stop, __pyx_v_have_step, 1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 770, __pyx_L1_error) + + /* "View.MemoryView":776 + * have_start, have_stop, have_step, + * True) + * new_ndim += 1 # <<<<<<<<<<<<<< + * + * if isinstance(memview, _memoryviewslice): + */ + __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); + } + __pyx_L6:; + + /* "View.MemoryView":748 + * cdef bint have_start, have_stop, have_step + * + * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< + * if PyIndex_Check(index): + * slice_memviewslice( + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":778 + * new_ndim += 1 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":779 + * + * if isinstance(memview, _memoryviewslice): + * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< + * memviewsliceobj.to_object_func, + * memviewsliceobj.to_dtype_func, + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + + /* "View.MemoryView":780 + * if isinstance(memview, _memoryviewslice): + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, # <<<<<<<<<<<<<< + * memviewsliceobj.to_dtype_func, + * memview.dtype_is_object) + */ + if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 780, __pyx_L1_error) } + + /* "View.MemoryView":781 + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, + * memviewsliceobj.to_dtype_func, # <<<<<<<<<<<<<< + * memview.dtype_is_object) + * else: + */ + if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 781, __pyx_L1_error) } + + /* "View.MemoryView":779 + * + * if isinstance(memview, _memoryviewslice): + * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< + * memviewsliceobj.to_object_func, + * memviewsliceobj.to_dtype_func, + */ + __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, __pyx_v_memviewsliceobj->to_object_func, __pyx_v_memviewsliceobj->to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 779, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 779, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":778 + * new_ndim += 1 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, + */ + } + + /* "View.MemoryView":784 + * memview.dtype_is_object) + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< + * memview.dtype_is_object) + * + */ + /*else*/ { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + + /* "View.MemoryView":785 + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, + * memview.dtype_is_object) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 784, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "View.MemoryView":784 + * memview.dtype_is_object) + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< + * memview.dtype_is_object) + * + */ + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 784, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":712 + * + * @cname('__pyx_memview_slice') + * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< + * cdef int new_ndim = 0, suboffset_dim = -1, dim + * cdef bint negative_step + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("View.MemoryView.memview_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_memviewsliceobj); + __Pyx_XDECREF(__pyx_v_index); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":809 + * + * @cname('__pyx_memoryview_slice_memviewslice') + * cdef int slice_memviewslice( # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, + */ + +static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, Py_ssize_t __pyx_v_shape, Py_ssize_t __pyx_v_stride, Py_ssize_t __pyx_v_suboffset, int __pyx_v_dim, int __pyx_v_new_ndim, int *__pyx_v_suboffset_dim, Py_ssize_t __pyx_v_start, Py_ssize_t __pyx_v_stop, Py_ssize_t __pyx_v_step, int __pyx_v_have_start, int __pyx_v_have_stop, int __pyx_v_have_step, int __pyx_v_is_slice) { + Py_ssize_t __pyx_v_new_shape; + int __pyx_v_negative_step; + int __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":829 + * cdef bint negative_step + * + * if not is_slice: # <<<<<<<<<<<<<< + * + * if start < 0: + */ + __pyx_t_1 = ((!(__pyx_v_is_slice != 0)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":831 + * if not is_slice: + * + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if not 0 <= start < shape: + */ + __pyx_t_1 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":832 + * + * if start < 0: + * start += shape # <<<<<<<<<<<<<< + * if not 0 <= start < shape: + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + */ + __pyx_v_start = (__pyx_v_start + __pyx_v_shape); + + /* "View.MemoryView":831 + * if not is_slice: + * + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if not 0 <= start < shape: + */ + } + + /* "View.MemoryView":833 + * if start < 0: + * start += shape + * if not 0 <= start < shape: # <<<<<<<<<<<<<< + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + * else: + */ + __pyx_t_1 = (0 <= __pyx_v_start); + if (__pyx_t_1) { + __pyx_t_1 = (__pyx_v_start < __pyx_v_shape); + } + __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":834 + * start += shape + * if not 0 <= start < shape: + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) # <<<<<<<<<<<<<< + * else: + * + */ + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"Index out of bounds (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 834, __pyx_L1_error) + + /* "View.MemoryView":833 + * if start < 0: + * start += shape + * if not 0 <= start < shape: # <<<<<<<<<<<<<< + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + * else: + */ + } + + /* "View.MemoryView":829 + * cdef bint negative_step + * + * if not is_slice: # <<<<<<<<<<<<<< + * + * if start < 0: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":837 + * else: + * + * negative_step = have_step != 0 and step < 0 # <<<<<<<<<<<<<< + * + * if have_step and step == 0: + */ + /*else*/ { + __pyx_t_1 = ((__pyx_v_have_step != 0) != 0); + if (__pyx_t_1) { + } else { + __pyx_t_2 = __pyx_t_1; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_1 = ((__pyx_v_step < 0) != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L6_bool_binop_done:; + __pyx_v_negative_step = __pyx_t_2; + + /* "View.MemoryView":839 + * negative_step = have_step != 0 and step < 0 + * + * if have_step and step == 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) + * + */ + __pyx_t_1 = (__pyx_v_have_step != 0); + if (__pyx_t_1) { + } else { + __pyx_t_2 = __pyx_t_1; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_1 = ((__pyx_v_step == 0) != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L9_bool_binop_done:; + if (__pyx_t_2) { + + /* "View.MemoryView":840 + * + * if have_step and step == 0: + * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Step may not be zero (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 840, __pyx_L1_error) + + /* "View.MemoryView":839 + * negative_step = have_step != 0 and step < 0 + * + * if have_step and step == 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) + * + */ + } + + /* "View.MemoryView":843 + * + * + * if have_start: # <<<<<<<<<<<<<< + * if start < 0: + * start += shape + */ + __pyx_t_2 = (__pyx_v_have_start != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":844 + * + * if have_start: + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if start < 0: + */ + __pyx_t_2 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":845 + * if have_start: + * if start < 0: + * start += shape # <<<<<<<<<<<<<< + * if start < 0: + * start = 0 + */ + __pyx_v_start = (__pyx_v_start + __pyx_v_shape); + + /* "View.MemoryView":846 + * if start < 0: + * start += shape + * if start < 0: # <<<<<<<<<<<<<< + * start = 0 + * elif start >= shape: + */ + __pyx_t_2 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":847 + * start += shape + * if start < 0: + * start = 0 # <<<<<<<<<<<<<< + * elif start >= shape: + * if negative_step: + */ + __pyx_v_start = 0; + + /* "View.MemoryView":846 + * if start < 0: + * start += shape + * if start < 0: # <<<<<<<<<<<<<< + * start = 0 + * elif start >= shape: + */ + } + + /* "View.MemoryView":844 + * + * if have_start: + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if start < 0: + */ + goto __pyx_L12; + } + + /* "View.MemoryView":848 + * if start < 0: + * start = 0 + * elif start >= shape: # <<<<<<<<<<<<<< + * if negative_step: + * start = shape - 1 + */ + __pyx_t_2 = ((__pyx_v_start >= __pyx_v_shape) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":849 + * start = 0 + * elif start >= shape: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":850 + * elif start >= shape: + * if negative_step: + * start = shape - 1 # <<<<<<<<<<<<<< + * else: + * start = shape + */ + __pyx_v_start = (__pyx_v_shape - 1); + + /* "View.MemoryView":849 + * start = 0 + * elif start >= shape: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + goto __pyx_L14; + } + + /* "View.MemoryView":852 + * start = shape - 1 + * else: + * start = shape # <<<<<<<<<<<<<< + * else: + * if negative_step: + */ + /*else*/ { + __pyx_v_start = __pyx_v_shape; + } + __pyx_L14:; + + /* "View.MemoryView":848 + * if start < 0: + * start = 0 + * elif start >= shape: # <<<<<<<<<<<<<< + * if negative_step: + * start = shape - 1 + */ + } + __pyx_L12:; + + /* "View.MemoryView":843 + * + * + * if have_start: # <<<<<<<<<<<<<< + * if start < 0: + * start += shape + */ + goto __pyx_L11; + } + + /* "View.MemoryView":854 + * start = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + /*else*/ { + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":855 + * else: + * if negative_step: + * start = shape - 1 # <<<<<<<<<<<<<< + * else: + * start = 0 + */ + __pyx_v_start = (__pyx_v_shape - 1); + + /* "View.MemoryView":854 + * start = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + goto __pyx_L15; + } + + /* "View.MemoryView":857 + * start = shape - 1 + * else: + * start = 0 # <<<<<<<<<<<<<< + * + * if have_stop: + */ + /*else*/ { + __pyx_v_start = 0; + } + __pyx_L15:; + } + __pyx_L11:; + + /* "View.MemoryView":859 + * start = 0 + * + * if have_stop: # <<<<<<<<<<<<<< + * if stop < 0: + * stop += shape + */ + __pyx_t_2 = (__pyx_v_have_stop != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":860 + * + * if have_stop: + * if stop < 0: # <<<<<<<<<<<<<< + * stop += shape + * if stop < 0: + */ + __pyx_t_2 = ((__pyx_v_stop < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":861 + * if have_stop: + * if stop < 0: + * stop += shape # <<<<<<<<<<<<<< + * if stop < 0: + * stop = 0 + */ + __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape); + + /* "View.MemoryView":862 + * if stop < 0: + * stop += shape + * if stop < 0: # <<<<<<<<<<<<<< + * stop = 0 + * elif stop > shape: + */ + __pyx_t_2 = ((__pyx_v_stop < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":863 + * stop += shape + * if stop < 0: + * stop = 0 # <<<<<<<<<<<<<< + * elif stop > shape: + * stop = shape + */ + __pyx_v_stop = 0; + + /* "View.MemoryView":862 + * if stop < 0: + * stop += shape + * if stop < 0: # <<<<<<<<<<<<<< + * stop = 0 + * elif stop > shape: + */ + } + + /* "View.MemoryView":860 + * + * if have_stop: + * if stop < 0: # <<<<<<<<<<<<<< + * stop += shape + * if stop < 0: + */ + goto __pyx_L17; + } + + /* "View.MemoryView":864 + * if stop < 0: + * stop = 0 + * elif stop > shape: # <<<<<<<<<<<<<< + * stop = shape + * else: + */ + __pyx_t_2 = ((__pyx_v_stop > __pyx_v_shape) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":865 + * stop = 0 + * elif stop > shape: + * stop = shape # <<<<<<<<<<<<<< + * else: + * if negative_step: + */ + __pyx_v_stop = __pyx_v_shape; + + /* "View.MemoryView":864 + * if stop < 0: + * stop = 0 + * elif stop > shape: # <<<<<<<<<<<<<< + * stop = shape + * else: + */ + } + __pyx_L17:; + + /* "View.MemoryView":859 + * start = 0 + * + * if have_stop: # <<<<<<<<<<<<<< + * if stop < 0: + * stop += shape + */ + goto __pyx_L16; + } + + /* "View.MemoryView":867 + * stop = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * stop = -1 + * else: + */ + /*else*/ { + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":868 + * else: + * if negative_step: + * stop = -1 # <<<<<<<<<<<<<< + * else: + * stop = shape + */ + __pyx_v_stop = -1L; + + /* "View.MemoryView":867 + * stop = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * stop = -1 + * else: + */ + goto __pyx_L19; + } + + /* "View.MemoryView":870 + * stop = -1 + * else: + * stop = shape # <<<<<<<<<<<<<< + * + * if not have_step: + */ + /*else*/ { + __pyx_v_stop = __pyx_v_shape; + } + __pyx_L19:; + } + __pyx_L16:; + + /* "View.MemoryView":872 + * stop = shape + * + * if not have_step: # <<<<<<<<<<<<<< + * step = 1 + * + */ + __pyx_t_2 = ((!(__pyx_v_have_step != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":873 + * + * if not have_step: + * step = 1 # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_step = 1; + + /* "View.MemoryView":872 + * stop = shape + * + * if not have_step: # <<<<<<<<<<<<<< + * step = 1 + * + */ + } + + /* "View.MemoryView":877 + * + * with cython.cdivision(True): + * new_shape = (stop - start) // step # <<<<<<<<<<<<<< + * + * if (stop - start) - step * new_shape: + */ + __pyx_v_new_shape = ((__pyx_v_stop - __pyx_v_start) / __pyx_v_step); + + /* "View.MemoryView":879 + * new_shape = (stop - start) // step + * + * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< + * new_shape += 1 + * + */ + __pyx_t_2 = (((__pyx_v_stop - __pyx_v_start) - (__pyx_v_step * __pyx_v_new_shape)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":880 + * + * if (stop - start) - step * new_shape: + * new_shape += 1 # <<<<<<<<<<<<<< + * + * if new_shape < 0: + */ + __pyx_v_new_shape = (__pyx_v_new_shape + 1); + + /* "View.MemoryView":879 + * new_shape = (stop - start) // step + * + * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< + * new_shape += 1 + * + */ + } + + /* "View.MemoryView":882 + * new_shape += 1 + * + * if new_shape < 0: # <<<<<<<<<<<<<< + * new_shape = 0 + * + */ + __pyx_t_2 = ((__pyx_v_new_shape < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":883 + * + * if new_shape < 0: + * new_shape = 0 # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_new_shape = 0; + + /* "View.MemoryView":882 + * new_shape += 1 + * + * if new_shape < 0: # <<<<<<<<<<<<<< + * new_shape = 0 + * + */ + } + + /* "View.MemoryView":886 + * + * + * dst.strides[new_ndim] = stride * step # <<<<<<<<<<<<<< + * dst.shape[new_ndim] = new_shape + * dst.suboffsets[new_ndim] = suboffset + */ + (__pyx_v_dst->strides[__pyx_v_new_ndim]) = (__pyx_v_stride * __pyx_v_step); + + /* "View.MemoryView":887 + * + * dst.strides[new_ndim] = stride * step + * dst.shape[new_ndim] = new_shape # <<<<<<<<<<<<<< + * dst.suboffsets[new_ndim] = suboffset + * + */ + (__pyx_v_dst->shape[__pyx_v_new_ndim]) = __pyx_v_new_shape; + + /* "View.MemoryView":888 + * dst.strides[new_ndim] = stride * step + * dst.shape[new_ndim] = new_shape + * dst.suboffsets[new_ndim] = suboffset # <<<<<<<<<<<<<< + * + * + */ + (__pyx_v_dst->suboffsets[__pyx_v_new_ndim]) = __pyx_v_suboffset; + } + __pyx_L3:; + + /* "View.MemoryView":891 + * + * + * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< + * dst.data += start * stride + * else: + */ + __pyx_t_2 = (((__pyx_v_suboffset_dim[0]) < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":892 + * + * if suboffset_dim[0] < 0: + * dst.data += start * stride # <<<<<<<<<<<<<< + * else: + * dst.suboffsets[suboffset_dim[0]] += start * stride + */ + __pyx_v_dst->data = (__pyx_v_dst->data + (__pyx_v_start * __pyx_v_stride)); + + /* "View.MemoryView":891 + * + * + * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< + * dst.data += start * stride + * else: + */ + goto __pyx_L23; + } + + /* "View.MemoryView":894 + * dst.data += start * stride + * else: + * dst.suboffsets[suboffset_dim[0]] += start * stride # <<<<<<<<<<<<<< + * + * if suboffset >= 0: + */ + /*else*/ { + __pyx_t_3 = (__pyx_v_suboffset_dim[0]); + (__pyx_v_dst->suboffsets[__pyx_t_3]) = ((__pyx_v_dst->suboffsets[__pyx_t_3]) + (__pyx_v_start * __pyx_v_stride)); + } + __pyx_L23:; + + /* "View.MemoryView":896 + * dst.suboffsets[suboffset_dim[0]] += start * stride + * + * if suboffset >= 0: # <<<<<<<<<<<<<< + * if not is_slice: + * if new_ndim == 0: + */ + __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":897 + * + * if suboffset >= 0: + * if not is_slice: # <<<<<<<<<<<<<< + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset + */ + __pyx_t_2 = ((!(__pyx_v_is_slice != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":898 + * if suboffset >= 0: + * if not is_slice: + * if new_ndim == 0: # <<<<<<<<<<<<<< + * dst.data = ( dst.data)[0] + suboffset + * else: + */ + __pyx_t_2 = ((__pyx_v_new_ndim == 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":899 + * if not is_slice: + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset # <<<<<<<<<<<<<< + * else: + * _err_dim(IndexError, "All dimensions preceding dimension %d " + */ + __pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset); + + /* "View.MemoryView":898 + * if suboffset >= 0: + * if not is_slice: + * if new_ndim == 0: # <<<<<<<<<<<<<< + * dst.data = ( dst.data)[0] + suboffset + * else: + */ + goto __pyx_L26; + } + + /* "View.MemoryView":901 + * dst.data = ( dst.data)[0] + suboffset + * else: + * _err_dim(IndexError, "All dimensions preceding dimension %d " # <<<<<<<<<<<<<< + * "must be indexed and not sliced", dim) + * else: + */ + /*else*/ { + + /* "View.MemoryView":902 + * else: + * _err_dim(IndexError, "All dimensions preceding dimension %d " + * "must be indexed and not sliced", dim) # <<<<<<<<<<<<<< + * else: + * suboffset_dim[0] = new_ndim + */ + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"All dimensions preceding dimension %d must be indexed and not sliced"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 901, __pyx_L1_error) + } + __pyx_L26:; + + /* "View.MemoryView":897 + * + * if suboffset >= 0: + * if not is_slice: # <<<<<<<<<<<<<< + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset + */ + goto __pyx_L25; + } + + /* "View.MemoryView":904 + * "must be indexed and not sliced", dim) + * else: + * suboffset_dim[0] = new_ndim # <<<<<<<<<<<<<< + * + * return 0 + */ + /*else*/ { + (__pyx_v_suboffset_dim[0]) = __pyx_v_new_ndim; + } + __pyx_L25:; + + /* "View.MemoryView":896 + * dst.suboffsets[suboffset_dim[0]] += start * stride + * + * if suboffset >= 0: # <<<<<<<<<<<<<< + * if not is_slice: + * if new_ndim == 0: + */ + } + + /* "View.MemoryView":906 + * suboffset_dim[0] = new_ndim + * + * return 0 # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":809 + * + * @cname('__pyx_memoryview_slice_memviewslice') + * cdef int slice_memviewslice( # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.slice_memviewslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":912 + * + * @cname('__pyx_pybuffer_index') + * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 + */ + +static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, Py_ssize_t __pyx_v_index, Py_ssize_t __pyx_v_dim) { + Py_ssize_t __pyx_v_shape; + Py_ssize_t __pyx_v_stride; + Py_ssize_t __pyx_v_suboffset; + Py_ssize_t __pyx_v_itemsize; + char *__pyx_v_resultp; + char *__pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("pybuffer_index", 0); + + /* "View.MemoryView":914 + * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 # <<<<<<<<<<<<<< + * cdef Py_ssize_t itemsize = view.itemsize + * cdef char *resultp + */ + __pyx_v_suboffset = -1L; + + /* "View.MemoryView":915 + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 + * cdef Py_ssize_t itemsize = view.itemsize # <<<<<<<<<<<<<< + * cdef char *resultp + * + */ + __pyx_t_1 = __pyx_v_view->itemsize; + __pyx_v_itemsize = __pyx_t_1; + + /* "View.MemoryView":918 + * cdef char *resultp + * + * if view.ndim == 0: # <<<<<<<<<<<<<< + * shape = view.len / itemsize + * stride = itemsize + */ + __pyx_t_2 = ((__pyx_v_view->ndim == 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":919 + * + * if view.ndim == 0: + * shape = view.len / itemsize # <<<<<<<<<<<<<< + * stride = itemsize + * else: + */ + if (unlikely(__pyx_v_itemsize == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); + __PYX_ERR(1, 919, __pyx_L1_error) + } + else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_view->len))) { + PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); + __PYX_ERR(1, 919, __pyx_L1_error) + } + __pyx_v_shape = __Pyx_div_Py_ssize_t(__pyx_v_view->len, __pyx_v_itemsize); + + /* "View.MemoryView":920 + * if view.ndim == 0: + * shape = view.len / itemsize + * stride = itemsize # <<<<<<<<<<<<<< + * else: + * shape = view.shape[dim] + */ + __pyx_v_stride = __pyx_v_itemsize; + + /* "View.MemoryView":918 + * cdef char *resultp + * + * if view.ndim == 0: # <<<<<<<<<<<<<< + * shape = view.len / itemsize + * stride = itemsize + */ + goto __pyx_L3; + } + + /* "View.MemoryView":922 + * stride = itemsize + * else: + * shape = view.shape[dim] # <<<<<<<<<<<<<< + * stride = view.strides[dim] + * if view.suboffsets != NULL: + */ + /*else*/ { + __pyx_v_shape = (__pyx_v_view->shape[__pyx_v_dim]); + + /* "View.MemoryView":923 + * else: + * shape = view.shape[dim] + * stride = view.strides[dim] # <<<<<<<<<<<<<< + * if view.suboffsets != NULL: + * suboffset = view.suboffsets[dim] + */ + __pyx_v_stride = (__pyx_v_view->strides[__pyx_v_dim]); + + /* "View.MemoryView":924 + * shape = view.shape[dim] + * stride = view.strides[dim] + * if view.suboffsets != NULL: # <<<<<<<<<<<<<< + * suboffset = view.suboffsets[dim] + * + */ + __pyx_t_2 = ((__pyx_v_view->suboffsets != NULL) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":925 + * stride = view.strides[dim] + * if view.suboffsets != NULL: + * suboffset = view.suboffsets[dim] # <<<<<<<<<<<<<< + * + * if index < 0: + */ + __pyx_v_suboffset = (__pyx_v_view->suboffsets[__pyx_v_dim]); + + /* "View.MemoryView":924 + * shape = view.shape[dim] + * stride = view.strides[dim] + * if view.suboffsets != NULL: # <<<<<<<<<<<<<< + * suboffset = view.suboffsets[dim] + * + */ + } + } + __pyx_L3:; + + /* "View.MemoryView":927 + * suboffset = view.suboffsets[dim] + * + * if index < 0: # <<<<<<<<<<<<<< + * index += view.shape[dim] + * if index < 0: + */ + __pyx_t_2 = ((__pyx_v_index < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":928 + * + * if index < 0: + * index += view.shape[dim] # <<<<<<<<<<<<<< + * if index < 0: + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + */ + __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim])); + + /* "View.MemoryView":929 + * if index < 0: + * index += view.shape[dim] + * if index < 0: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + __pyx_t_2 = ((__pyx_v_index < 0) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":930 + * index += view.shape[dim] + * if index < 0: + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<< + * + * if index >= shape: + */ + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 930, __pyx_L1_error) + + /* "View.MemoryView":929 + * if index < 0: + * index += view.shape[dim] + * if index < 0: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + } + + /* "View.MemoryView":927 + * suboffset = view.suboffsets[dim] + * + * if index < 0: # <<<<<<<<<<<<<< + * index += view.shape[dim] + * if index < 0: + */ + } + + /* "View.MemoryView":932 + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + * if index >= shape: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + __pyx_t_2 = ((__pyx_v_index >= __pyx_v_shape) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":933 + * + * if index >= shape: + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<< + * + * resultp = bufp + index * stride + */ + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 933, __pyx_L1_error) + + /* "View.MemoryView":932 + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + * if index >= shape: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + } + + /* "View.MemoryView":935 + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + * resultp = bufp + index * stride # <<<<<<<<<<<<<< + * if suboffset >= 0: + * resultp = ( resultp)[0] + suboffset + */ + __pyx_v_resultp = (__pyx_v_bufp + (__pyx_v_index * __pyx_v_stride)); + + /* "View.MemoryView":936 + * + * resultp = bufp + index * stride + * if suboffset >= 0: # <<<<<<<<<<<<<< + * resultp = ( resultp)[0] + suboffset + * + */ + __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":937 + * resultp = bufp + index * stride + * if suboffset >= 0: + * resultp = ( resultp)[0] + suboffset # <<<<<<<<<<<<<< + * + * return resultp + */ + __pyx_v_resultp = ((((char **)__pyx_v_resultp)[0]) + __pyx_v_suboffset); + + /* "View.MemoryView":936 + * + * resultp = bufp + index * stride + * if suboffset >= 0: # <<<<<<<<<<<<<< + * resultp = ( resultp)[0] + suboffset + * + */ + } + + /* "View.MemoryView":939 + * resultp = ( resultp)[0] + suboffset + * + * return resultp # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_resultp; + goto __pyx_L0; + + /* "View.MemoryView":912 + * + * @cname('__pyx_pybuffer_index') + * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView.pybuffer_index", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":945 + * + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< + * cdef int ndim = memslice.memview.view.ndim + * + */ + +static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { + int __pyx_v_ndim; + Py_ssize_t *__pyx_v_shape; + Py_ssize_t *__pyx_v_strides; + int __pyx_v_i; + int __pyx_v_j; + int __pyx_r; + int __pyx_t_1; + Py_ssize_t *__pyx_t_2; + long __pyx_t_3; + long __pyx_t_4; + Py_ssize_t __pyx_t_5; + Py_ssize_t __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":946 + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: + * cdef int ndim = memslice.memview.view.ndim # <<<<<<<<<<<<<< + * + * cdef Py_ssize_t *shape = memslice.shape + */ + __pyx_t_1 = __pyx_v_memslice->memview->view.ndim; + __pyx_v_ndim = __pyx_t_1; + + /* "View.MemoryView":948 + * cdef int ndim = memslice.memview.view.ndim + * + * cdef Py_ssize_t *shape = memslice.shape # <<<<<<<<<<<<<< + * cdef Py_ssize_t *strides = memslice.strides + * + */ + __pyx_t_2 = __pyx_v_memslice->shape; + __pyx_v_shape = __pyx_t_2; + + /* "View.MemoryView":949 + * + * cdef Py_ssize_t *shape = memslice.shape + * cdef Py_ssize_t *strides = memslice.strides # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __pyx_v_memslice->strides; + __pyx_v_strides = __pyx_t_2; + + /* "View.MemoryView":953 + * + * cdef int i, j + * for i in range(ndim / 2): # <<<<<<<<<<<<<< + * j = ndim - 1 - i + * strides[i], strides[j] = strides[j], strides[i] + */ + __pyx_t_3 = __Pyx_div_long(__pyx_v_ndim, 2); + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_1 = 0; __pyx_t_1 < __pyx_t_4; __pyx_t_1+=1) { + __pyx_v_i = __pyx_t_1; + + /* "View.MemoryView":954 + * cdef int i, j + * for i in range(ndim / 2): + * j = ndim - 1 - i # <<<<<<<<<<<<<< + * strides[i], strides[j] = strides[j], strides[i] + * shape[i], shape[j] = shape[j], shape[i] + */ + __pyx_v_j = ((__pyx_v_ndim - 1) - __pyx_v_i); + + /* "View.MemoryView":955 + * for i in range(ndim / 2): + * j = ndim - 1 - i + * strides[i], strides[j] = strides[j], strides[i] # <<<<<<<<<<<<<< + * shape[i], shape[j] = shape[j], shape[i] + * + */ + __pyx_t_5 = (__pyx_v_strides[__pyx_v_j]); + __pyx_t_6 = (__pyx_v_strides[__pyx_v_i]); + (__pyx_v_strides[__pyx_v_i]) = __pyx_t_5; + (__pyx_v_strides[__pyx_v_j]) = __pyx_t_6; + + /* "View.MemoryView":956 + * j = ndim - 1 - i + * strides[i], strides[j] = strides[j], strides[i] + * shape[i], shape[j] = shape[j], shape[i] # <<<<<<<<<<<<<< + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: + */ + __pyx_t_6 = (__pyx_v_shape[__pyx_v_j]); + __pyx_t_5 = (__pyx_v_shape[__pyx_v_i]); + (__pyx_v_shape[__pyx_v_i]) = __pyx_t_6; + (__pyx_v_shape[__pyx_v_j]) = __pyx_t_5; + + /* "View.MemoryView":958 + * shape[i], shape[j] = shape[j], shape[i] + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + */ + __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 0) != 0); + if (!__pyx_t_8) { + } else { + __pyx_t_7 = __pyx_t_8; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_j]) >= 0) != 0); + __pyx_t_7 = __pyx_t_8; + __pyx_L6_bool_binop_done:; + if (__pyx_t_7) { + + /* "View.MemoryView":959 + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") # <<<<<<<<<<<<<< + * + * return 1 + */ + __pyx_t_9 = __pyx_memoryview_err(__pyx_builtin_ValueError, ((char *)"Cannot transpose memoryview with indirect dimensions")); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 959, __pyx_L1_error) + + /* "View.MemoryView":958 + * shape[i], shape[j] = shape[j], shape[i] + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + */ + } + } + + /* "View.MemoryView":961 + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + * return 1 # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = 1; + goto __pyx_L0; + + /* "View.MemoryView":945 + * + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< + * cdef int ndim = memslice.memview.view.ndim + * + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.transpose_memslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = 0; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":978 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + */ + +/* Python wrapper */ +static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":979 + * + * def __dealloc__(self): + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<< + * + * cdef convert_item_to_object(self, char *itemp): + */ + __PYX_XDEC_MEMVIEW((&__pyx_v_self->from_slice), 1); + + /* "View.MemoryView":978 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":981 + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * if self.to_object_func != NULL: + * return self.to_object_func(itemp) + */ + +static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("convert_item_to_object", 0); + + /* "View.MemoryView":982 + * + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: # <<<<<<<<<<<<<< + * return self.to_object_func(itemp) + * else: + */ + __pyx_t_1 = ((__pyx_v_self->to_object_func != NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":983 + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: + * return self.to_object_func(itemp) # <<<<<<<<<<<<<< + * else: + * return memoryview.convert_item_to_object(self, itemp) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_v_self->to_object_func(__pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 983, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":982 + * + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: # <<<<<<<<<<<<<< + * return self.to_object_func(itemp) + * else: + */ + } + + /* "View.MemoryView":985 + * return self.to_object_func(itemp) + * else: + * return memoryview.convert_item_to_object(self, itemp) # <<<<<<<<<<<<<< + * + * cdef assign_item_from_object(self, char *itemp, object value): + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_memoryview_convert_item_to_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 985, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":981 + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * if self.to_object_func != NULL: + * return self.to_object_func(itemp) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":987 + * return memoryview.convert_item_to_object(self, itemp) + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * if self.to_dtype_func != NULL: + * self.to_dtype_func(itemp, value) + */ + +static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("assign_item_from_object", 0); + + /* "View.MemoryView":988 + * + * cdef assign_item_from_object(self, char *itemp, object value): + * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< + * self.to_dtype_func(itemp, value) + * else: + */ + __pyx_t_1 = ((__pyx_v_self->to_dtype_func != NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":989 + * cdef assign_item_from_object(self, char *itemp, object value): + * if self.to_dtype_func != NULL: + * self.to_dtype_func(itemp, value) # <<<<<<<<<<<<<< + * else: + * memoryview.assign_item_from_object(self, itemp, value) + */ + __pyx_t_2 = __pyx_v_self->to_dtype_func(__pyx_v_itemp, __pyx_v_value); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 989, __pyx_L1_error) + + /* "View.MemoryView":988 + * + * cdef assign_item_from_object(self, char *itemp, object value): + * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< + * self.to_dtype_func(itemp, value) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":991 + * self.to_dtype_func(itemp, value) + * else: + * memoryview.assign_item_from_object(self, itemp, value) # <<<<<<<<<<<<<< + * + * @property + */ + /*else*/ { + __pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 991, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L3:; + + /* "View.MemoryView":987 + * return memoryview.convert_item_to_object(self, itemp) + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * if self.to_dtype_func != NULL: + * self.to_dtype_func(itemp, value) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":994 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.from_object + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":995 + * @property + * def base(self): + * return self.from_object # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->from_object); + __pyx_r = __pyx_v_self->from_object; + goto __pyx_L0; + + /* "View.MemoryView":994 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.from_object + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_memoryviewslice___reduce_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__22, 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__23, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1001 + * + * @cname('__pyx_memoryview_fromslice') + * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< + * int ndim, + * object (*to_object_func)(char *), + */ + +static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewslice, int __pyx_v_ndim, PyObject *(*__pyx_v_to_object_func)(char *), int (*__pyx_v_to_dtype_func)(char *, PyObject *), int __pyx_v_dtype_is_object) { + struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; + Py_ssize_t __pyx_v_suboffset; + PyObject *__pyx_v_length = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_TypeInfo *__pyx_t_4; + Py_buffer __pyx_t_5; + Py_ssize_t *__pyx_t_6; + Py_ssize_t *__pyx_t_7; + Py_ssize_t *__pyx_t_8; + Py_ssize_t __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_fromslice", 0); + + /* "View.MemoryView":1009 + * cdef _memoryviewslice result + * + * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< + * return None + * + */ + __pyx_t_1 = ((((PyObject *)__pyx_v_memviewslice.memview) == Py_None) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1010 + * + * if memviewslice.memview == Py_None: + * return None # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "View.MemoryView":1009 + * cdef _memoryviewslice result + * + * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< + * return None + * + */ + } + + /* "View.MemoryView":1015 + * + * + * result = _memoryviewslice(None, 0, dtype_is_object) # <<<<<<<<<<<<<< + * + * result.from_slice = memviewslice + */ + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1015, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1015, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1015, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":1017 + * result = _memoryviewslice(None, 0, dtype_is_object) + * + * result.from_slice = memviewslice # <<<<<<<<<<<<<< + * __PYX_INC_MEMVIEW(&memviewslice, 1) + * + */ + __pyx_v_result->from_slice = __pyx_v_memviewslice; + + /* "View.MemoryView":1018 + * + * result.from_slice = memviewslice + * __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<< + * + * result.from_object = ( memviewslice.memview).base + */ + __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1); + + /* "View.MemoryView":1020 + * __PYX_INC_MEMVIEW(&memviewslice, 1) + * + * result.from_object = ( memviewslice.memview).base # <<<<<<<<<<<<<< + * result.typeinfo = memviewslice.memview.typeinfo + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_memviewslice.memview), __pyx_n_s_base); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1020, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_result->from_object); + __Pyx_DECREF(__pyx_v_result->from_object); + __pyx_v_result->from_object = __pyx_t_2; + __pyx_t_2 = 0; + + /* "View.MemoryView":1021 + * + * result.from_object = ( memviewslice.memview).base + * result.typeinfo = memviewslice.memview.typeinfo # <<<<<<<<<<<<<< + * + * result.view = memviewslice.memview.view + */ + __pyx_t_4 = __pyx_v_memviewslice.memview->typeinfo; + __pyx_v_result->__pyx_base.typeinfo = __pyx_t_4; + + /* "View.MemoryView":1023 + * result.typeinfo = memviewslice.memview.typeinfo + * + * result.view = memviewslice.memview.view # <<<<<<<<<<<<<< + * result.view.buf = memviewslice.data + * result.view.ndim = ndim + */ + __pyx_t_5 = __pyx_v_memviewslice.memview->view; + __pyx_v_result->__pyx_base.view = __pyx_t_5; + + /* "View.MemoryView":1024 + * + * result.view = memviewslice.memview.view + * result.view.buf = memviewslice.data # <<<<<<<<<<<<<< + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None + */ + __pyx_v_result->__pyx_base.view.buf = ((void *)__pyx_v_memviewslice.data); + + /* "View.MemoryView":1025 + * result.view = memviewslice.memview.view + * result.view.buf = memviewslice.data + * result.view.ndim = ndim # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &result.view).obj = Py_None + * Py_INCREF(Py_None) + */ + __pyx_v_result->__pyx_base.view.ndim = __pyx_v_ndim; + + /* "View.MemoryView":1026 + * result.view.buf = memviewslice.data + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * + */ + ((Py_buffer *)(&__pyx_v_result->__pyx_base.view))->obj = Py_None; + + /* "View.MemoryView":1027 + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: + */ + Py_INCREF(Py_None); + + /* "View.MemoryView":1029 + * Py_INCREF(Py_None) + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< + * result.flags = PyBUF_RECORDS + * else: + */ + __pyx_t_1 = ((((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->flags & PyBUF_WRITABLE) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1030 + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: + * result.flags = PyBUF_RECORDS # <<<<<<<<<<<<<< + * else: + * result.flags = PyBUF_RECORDS_RO + */ + __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS; + + /* "View.MemoryView":1029 + * Py_INCREF(Py_None) + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< + * result.flags = PyBUF_RECORDS + * else: + */ + goto __pyx_L4; + } + + /* "View.MemoryView":1032 + * result.flags = PyBUF_RECORDS + * else: + * result.flags = PyBUF_RECORDS_RO # <<<<<<<<<<<<<< + * + * result.view.shape = result.from_slice.shape + */ + /*else*/ { + __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS_RO; + } + __pyx_L4:; + + /* "View.MemoryView":1034 + * result.flags = PyBUF_RECORDS_RO + * + * result.view.shape = result.from_slice.shape # <<<<<<<<<<<<<< + * result.view.strides = result.from_slice.strides + * + */ + __pyx_v_result->__pyx_base.view.shape = ((Py_ssize_t *)__pyx_v_result->from_slice.shape); + + /* "View.MemoryView":1035 + * + * result.view.shape = result.from_slice.shape + * result.view.strides = result.from_slice.strides # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_result->__pyx_base.view.strides = ((Py_ssize_t *)__pyx_v_result->from_slice.strides); + + /* "View.MemoryView":1038 + * + * + * result.view.suboffsets = NULL # <<<<<<<<<<<<<< + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: + */ + __pyx_v_result->__pyx_base.view.suboffsets = NULL; + + /* "View.MemoryView":1039 + * + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: # <<<<<<<<<<<<<< + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets + */ + __pyx_t_7 = (__pyx_v_result->from_slice.suboffsets + __pyx_v_ndim); + for (__pyx_t_8 = __pyx_v_result->from_slice.suboffsets; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { + __pyx_t_6 = __pyx_t_8; + __pyx_v_suboffset = (__pyx_t_6[0]); + + /* "View.MemoryView":1040 + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * result.view.suboffsets = result.from_slice.suboffsets + * break + */ + __pyx_t_1 = ((__pyx_v_suboffset >= 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1041 + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets # <<<<<<<<<<<<<< + * break + * + */ + __pyx_v_result->__pyx_base.view.suboffsets = ((Py_ssize_t *)__pyx_v_result->from_slice.suboffsets); + + /* "View.MemoryView":1042 + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets + * break # <<<<<<<<<<<<<< + * + * result.view.len = result.view.itemsize + */ + goto __pyx_L6_break; + + /* "View.MemoryView":1040 + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * result.view.suboffsets = result.from_slice.suboffsets + * break + */ + } + } + __pyx_L6_break:; + + /* "View.MemoryView":1044 + * break + * + * result.view.len = result.view.itemsize # <<<<<<<<<<<<<< + * for length in result.view.shape[:ndim]: + * result.view.len *= length + */ + __pyx_t_9 = __pyx_v_result->__pyx_base.view.itemsize; + __pyx_v_result->__pyx_base.view.len = __pyx_t_9; + + /* "View.MemoryView":1045 + * + * result.view.len = result.view.itemsize + * for length in result.view.shape[:ndim]: # <<<<<<<<<<<<<< + * result.view.len *= length + * + */ + __pyx_t_7 = (__pyx_v_result->__pyx_base.view.shape + __pyx_v_ndim); + for (__pyx_t_8 = __pyx_v_result->__pyx_base.view.shape; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { + __pyx_t_6 = __pyx_t_8; + __pyx_t_2 = PyInt_FromSsize_t((__pyx_t_6[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":1046 + * result.view.len = result.view.itemsize + * for length in result.view.shape[:ndim]: + * result.view.len *= length # <<<<<<<<<<<<<< + * + * result.to_object_func = to_object_func + */ + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_result->__pyx_base.view.len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1046, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_t_2, __pyx_v_length); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1046, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 1046, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result->__pyx_base.view.len = __pyx_t_9; + } + + /* "View.MemoryView":1048 + * result.view.len *= length + * + * result.to_object_func = to_object_func # <<<<<<<<<<<<<< + * result.to_dtype_func = to_dtype_func + * + */ + __pyx_v_result->to_object_func = __pyx_v_to_object_func; + + /* "View.MemoryView":1049 + * + * result.to_object_func = to_object_func + * result.to_dtype_func = to_dtype_func # <<<<<<<<<<<<<< + * + * return result + */ + __pyx_v_result->to_dtype_func = __pyx_v_to_dtype_func; + + /* "View.MemoryView":1051 + * result.to_dtype_func = to_dtype_func + * + * return result # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "View.MemoryView":1001 + * + * @cname('__pyx_memoryview_fromslice') + * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< + * int ndim, + * object (*to_object_func)(char *), + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview_fromslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XDECREF(__pyx_v_length); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1054 + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') + * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + */ + +static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_mslice) { + struct __pyx_memoryviewslice_obj *__pyx_v_obj = 0; + __Pyx_memviewslice *__pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_slice_from_memview", 0); + + /* "View.MemoryView":1057 + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * obj = memview + * return &obj.from_slice + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1058 + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): + * obj = memview # <<<<<<<<<<<<<< + * return &obj.from_slice + * else: + */ + if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 1058, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_v_memview); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":1059 + * if isinstance(memview, _memoryviewslice): + * obj = memview + * return &obj.from_slice # <<<<<<<<<<<<<< + * else: + * slice_copy(memview, mslice) + */ + __pyx_r = (&__pyx_v_obj->from_slice); + goto __pyx_L0; + + /* "View.MemoryView":1057 + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * obj = memview + * return &obj.from_slice + */ + } + + /* "View.MemoryView":1061 + * return &obj.from_slice + * else: + * slice_copy(memview, mslice) # <<<<<<<<<<<<<< + * return mslice + * + */ + /*else*/ { + __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice); + + /* "View.MemoryView":1062 + * else: + * slice_copy(memview, mslice) + * return mslice # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_slice_copy') + */ + __pyx_r = __pyx_v_mslice; + goto __pyx_L0; + } + + /* "View.MemoryView":1054 + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') + * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.get_slice_from_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_obj); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1065 + * + * @cname('__pyx_memoryview_slice_copy') + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< + * cdef int dim + * cdef (Py_ssize_t*) shape, strides, suboffsets + */ + +static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_dst) { + int __pyx_v_dim; + Py_ssize_t *__pyx_v_shape; + Py_ssize_t *__pyx_v_strides; + Py_ssize_t *__pyx_v_suboffsets; + __Pyx_RefNannyDeclarations + Py_ssize_t *__pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + Py_ssize_t __pyx_t_5; + __Pyx_RefNannySetupContext("slice_copy", 0); + + /* "View.MemoryView":1069 + * cdef (Py_ssize_t*) shape, strides, suboffsets + * + * shape = memview.view.shape # <<<<<<<<<<<<<< + * strides = memview.view.strides + * suboffsets = memview.view.suboffsets + */ + __pyx_t_1 = __pyx_v_memview->view.shape; + __pyx_v_shape = __pyx_t_1; + + /* "View.MemoryView":1070 + * + * shape = memview.view.shape + * strides = memview.view.strides # <<<<<<<<<<<<<< + * suboffsets = memview.view.suboffsets + * + */ + __pyx_t_1 = __pyx_v_memview->view.strides; + __pyx_v_strides = __pyx_t_1; + + /* "View.MemoryView":1071 + * shape = memview.view.shape + * strides = memview.view.strides + * suboffsets = memview.view.suboffsets # <<<<<<<<<<<<<< + * + * dst.memview = <__pyx_memoryview *> memview + */ + __pyx_t_1 = __pyx_v_memview->view.suboffsets; + __pyx_v_suboffsets = __pyx_t_1; + + /* "View.MemoryView":1073 + * suboffsets = memview.view.suboffsets + * + * dst.memview = <__pyx_memoryview *> memview # <<<<<<<<<<<<<< + * dst.data = memview.view.buf + * + */ + __pyx_v_dst->memview = ((struct __pyx_memoryview_obj *)__pyx_v_memview); + + /* "View.MemoryView":1074 + * + * dst.memview = <__pyx_memoryview *> memview + * dst.data = memview.view.buf # <<<<<<<<<<<<<< + * + * for dim in range(memview.view.ndim): + */ + __pyx_v_dst->data = ((char *)__pyx_v_memview->view.buf); + + /* "View.MemoryView":1076 + * dst.data = memview.view.buf + * + * for dim in range(memview.view.ndim): # <<<<<<<<<<<<<< + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] + */ + __pyx_t_2 = __pyx_v_memview->view.ndim; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_dim = __pyx_t_4; + + /* "View.MemoryView":1077 + * + * for dim in range(memview.view.ndim): + * dst.shape[dim] = shape[dim] # <<<<<<<<<<<<<< + * dst.strides[dim] = strides[dim] + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 + */ + (__pyx_v_dst->shape[__pyx_v_dim]) = (__pyx_v_shape[__pyx_v_dim]); + + /* "View.MemoryView":1078 + * for dim in range(memview.view.ndim): + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] # <<<<<<<<<<<<<< + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 + * + */ + (__pyx_v_dst->strides[__pyx_v_dim]) = (__pyx_v_strides[__pyx_v_dim]); + + /* "View.MemoryView":1079 + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_object') + */ + if ((__pyx_v_suboffsets != 0)) { + __pyx_t_5 = (__pyx_v_suboffsets[__pyx_v_dim]); + } else { + __pyx_t_5 = -1L; + } + (__pyx_v_dst->suboffsets[__pyx_v_dim]) = __pyx_t_5; + } + + /* "View.MemoryView":1065 + * + * @cname('__pyx_memoryview_slice_copy') + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< + * cdef int dim + * cdef (Py_ssize_t*) shape, strides, suboffsets + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":1082 + * + * @cname('__pyx_memoryview_copy_object') + * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< + * "Create a new memoryview object" + * cdef __Pyx_memviewslice memviewslice + */ + +static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx_v_memview) { + __Pyx_memviewslice __pyx_v_memviewslice; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_copy", 0); + + /* "View.MemoryView":1085 + * "Create a new memoryview object" + * cdef __Pyx_memviewslice memviewslice + * slice_copy(memview, &memviewslice) # <<<<<<<<<<<<<< + * return memoryview_copy_from_slice(memview, &memviewslice) + * + */ + __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_memviewslice)); + + /* "View.MemoryView":1086 + * cdef __Pyx_memviewslice memviewslice + * slice_copy(memview, &memviewslice) + * return memoryview_copy_from_slice(memview, &memviewslice) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_object_from_slice') + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_memoryview_copy_object_from_slice(__pyx_v_memview, (&__pyx_v_memviewslice)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1086, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":1082 + * + * @cname('__pyx_memoryview_copy_object') + * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< + * "Create a new memoryview object" + * cdef __Pyx_memviewslice memviewslice + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview_copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1089 + * + * @cname('__pyx_memoryview_copy_object_from_slice') + * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< + * """ + * Create a new memoryview object from a given memoryview object and slice. + */ + +static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_memviewslice) { + PyObject *(*__pyx_v_to_object_func)(char *); + int (*__pyx_v_to_dtype_func)(char *, PyObject *); + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *(*__pyx_t_3)(char *); + int (*__pyx_t_4)(char *, PyObject *); + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 0); + + /* "View.MemoryView":1096 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1097 + * + * if isinstance(memview, _memoryviewslice): + * to_object_func = (<_memoryviewslice> memview).to_object_func # <<<<<<<<<<<<<< + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + * else: + */ + __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func; + __pyx_v_to_object_func = __pyx_t_3; + + /* "View.MemoryView":1098 + * if isinstance(memview, _memoryviewslice): + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func # <<<<<<<<<<<<<< + * else: + * to_object_func = NULL + */ + __pyx_t_4 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func; + __pyx_v_to_dtype_func = __pyx_t_4; + + /* "View.MemoryView":1096 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1100 + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + * else: + * to_object_func = NULL # <<<<<<<<<<<<<< + * to_dtype_func = NULL + * + */ + /*else*/ { + __pyx_v_to_object_func = NULL; + + /* "View.MemoryView":1101 + * else: + * to_object_func = NULL + * to_dtype_func = NULL # <<<<<<<<<<<<<< + * + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, + */ + __pyx_v_to_dtype_func = NULL; + } + __pyx_L3:; + + /* "View.MemoryView":1103 + * to_dtype_func = NULL + * + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, # <<<<<<<<<<<<<< + * to_object_func, to_dtype_func, + * memview.dtype_is_object) + */ + __Pyx_XDECREF(__pyx_r); + + /* "View.MemoryView":1105 + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, + * to_object_func, to_dtype_func, + * memview.dtype_is_object) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __pyx_memoryview_fromslice((__pyx_v_memviewslice[0]), __pyx_v_memview->view.ndim, __pyx_v_to_object_func, __pyx_v_to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "View.MemoryView":1089 + * + * @cname('__pyx_memoryview_copy_object_from_slice') + * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< + * """ + * Create a new memoryview object from a given memoryview object and slice. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview_copy_from_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1111 + * + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< + * if arg < 0: + * return -arg + */ + +static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { + Py_ssize_t __pyx_r; + int __pyx_t_1; + + /* "View.MemoryView":1112 + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: # <<<<<<<<<<<<<< + * return -arg + * else: + */ + __pyx_t_1 = ((__pyx_v_arg < 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1113 + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: + * return -arg # <<<<<<<<<<<<<< + * else: + * return arg + */ + __pyx_r = (-__pyx_v_arg); + goto __pyx_L0; + + /* "View.MemoryView":1112 + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: # <<<<<<<<<<<<<< + * return -arg + * else: + */ + } + + /* "View.MemoryView":1115 + * return -arg + * else: + * return arg # <<<<<<<<<<<<<< + * + * @cname('__pyx_get_best_slice_order') + */ + /*else*/ { + __pyx_r = __pyx_v_arg; + goto __pyx_L0; + } + + /* "View.MemoryView":1111 + * + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< + * if arg < 0: + * return -arg + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1118 + * + * @cname('__pyx_get_best_slice_order') + * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< + * """ + * Figure out the best memory access order for a given slice. + */ + +static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim) { + int __pyx_v_i; + Py_ssize_t __pyx_v_c_stride; + Py_ssize_t __pyx_v_f_stride; + char __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + + /* "View.MemoryView":1123 + * """ + * cdef int i + * cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<< + * cdef Py_ssize_t f_stride = 0 + * + */ + __pyx_v_c_stride = 0; + + /* "View.MemoryView":1124 + * cdef int i + * cdef Py_ssize_t c_stride = 0 + * cdef Py_ssize_t f_stride = 0 # <<<<<<<<<<<<<< + * + * for i in range(ndim - 1, -1, -1): + */ + __pyx_v_f_stride = 0; + + /* "View.MemoryView":1126 + * cdef Py_ssize_t f_stride = 0 + * + * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] + */ + for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { + __pyx_v_i = __pyx_t_1; + + /* "View.MemoryView":1127 + * + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * c_stride = mslice.strides[i] + * break + */ + __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1128 + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] # <<<<<<<<<<<<<< + * break + * + */ + __pyx_v_c_stride = (__pyx_v_mslice->strides[__pyx_v_i]); + + /* "View.MemoryView":1129 + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] + * break # <<<<<<<<<<<<<< + * + * for i in range(ndim): + */ + goto __pyx_L4_break; + + /* "View.MemoryView":1127 + * + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * c_stride = mslice.strides[i] + * break + */ + } + } + __pyx_L4_break:; + + /* "View.MemoryView":1131 + * break + * + * for i in range(ndim): # <<<<<<<<<<<<<< + * if mslice.shape[i] > 1: + * f_stride = mslice.strides[i] + */ + __pyx_t_1 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_1; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1132 + * + * for i in range(ndim): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * f_stride = mslice.strides[i] + * break + */ + __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1133 + * for i in range(ndim): + * if mslice.shape[i] > 1: + * f_stride = mslice.strides[i] # <<<<<<<<<<<<<< + * break + * + */ + __pyx_v_f_stride = (__pyx_v_mslice->strides[__pyx_v_i]); + + /* "View.MemoryView":1134 + * if mslice.shape[i] > 1: + * f_stride = mslice.strides[i] + * break # <<<<<<<<<<<<<< + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): + */ + goto __pyx_L7_break; + + /* "View.MemoryView":1132 + * + * for i in range(ndim): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * f_stride = mslice.strides[i] + * break + */ + } + } + __pyx_L7_break:; + + /* "View.MemoryView":1136 + * break + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< + * return 'C' + * else: + */ + __pyx_t_2 = ((abs_py_ssize_t(__pyx_v_c_stride) <= abs_py_ssize_t(__pyx_v_f_stride)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1137 + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): + * return 'C' # <<<<<<<<<<<<<< + * else: + * return 'F' + */ + __pyx_r = 'C'; + goto __pyx_L0; + + /* "View.MemoryView":1136 + * break + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< + * return 'C' + * else: + */ + } + + /* "View.MemoryView":1139 + * return 'C' + * else: + * return 'F' # <<<<<<<<<<<<<< + * + * @cython.cdivision(True) + */ + /*else*/ { + __pyx_r = 'F'; + goto __pyx_L0; + } + + /* "View.MemoryView":1118 + * + * @cname('__pyx_get_best_slice_order') + * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< + * """ + * Figure out the best memory access order for a given slice. + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1142 + * + * @cython.cdivision(True) + * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< + * char *dst_data, Py_ssize_t *dst_strides, + * Py_ssize_t *src_shape, Py_ssize_t *dst_shape, + */ + +static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v_src_strides, char *__pyx_v_dst_data, Py_ssize_t *__pyx_v_dst_strides, Py_ssize_t *__pyx_v_src_shape, Py_ssize_t *__pyx_v_dst_shape, int __pyx_v_ndim, size_t __pyx_v_itemsize) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + CYTHON_UNUSED Py_ssize_t __pyx_v_src_extent; + Py_ssize_t __pyx_v_dst_extent; + Py_ssize_t __pyx_v_src_stride; + Py_ssize_t __pyx_v_dst_stride; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + Py_ssize_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + Py_ssize_t __pyx_t_6; + + /* "View.MemoryView":1149 + * + * cdef Py_ssize_t i + * cdef Py_ssize_t src_extent = src_shape[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t dst_extent = dst_shape[0] + * cdef Py_ssize_t src_stride = src_strides[0] + */ + __pyx_v_src_extent = (__pyx_v_src_shape[0]); + + /* "View.MemoryView":1150 + * cdef Py_ssize_t i + * cdef Py_ssize_t src_extent = src_shape[0] + * cdef Py_ssize_t dst_extent = dst_shape[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t src_stride = src_strides[0] + * cdef Py_ssize_t dst_stride = dst_strides[0] + */ + __pyx_v_dst_extent = (__pyx_v_dst_shape[0]); + + /* "View.MemoryView":1151 + * cdef Py_ssize_t src_extent = src_shape[0] + * cdef Py_ssize_t dst_extent = dst_shape[0] + * cdef Py_ssize_t src_stride = src_strides[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t dst_stride = dst_strides[0] + * + */ + __pyx_v_src_stride = (__pyx_v_src_strides[0]); + + /* "View.MemoryView":1152 + * cdef Py_ssize_t dst_extent = dst_shape[0] + * cdef Py_ssize_t src_stride = src_strides[0] + * cdef Py_ssize_t dst_stride = dst_strides[0] # <<<<<<<<<<<<<< + * + * if ndim == 1: + */ + __pyx_v_dst_stride = (__pyx_v_dst_strides[0]); + + /* "View.MemoryView":1154 + * cdef Py_ssize_t dst_stride = dst_strides[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): + */ + __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1155 + * + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) + */ + __pyx_t_2 = ((__pyx_v_src_stride > 0) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L5_bool_binop_done; + } + __pyx_t_2 = ((__pyx_v_dst_stride > 0) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L5_bool_binop_done; + } + + /* "View.MemoryView":1156 + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): # <<<<<<<<<<<<<< + * memcpy(dst_data, src_data, itemsize * dst_extent) + * else: + */ + __pyx_t_2 = (((size_t)__pyx_v_src_stride) == __pyx_v_itemsize); + if (__pyx_t_2) { + __pyx_t_2 = (__pyx_v_itemsize == ((size_t)__pyx_v_dst_stride)); + } + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L5_bool_binop_done:; + + /* "View.MemoryView":1155 + * + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) + */ + if (__pyx_t_1) { + + /* "View.MemoryView":1157 + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) # <<<<<<<<<<<<<< + * else: + * for i in range(dst_extent): + */ + (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, (__pyx_v_itemsize * __pyx_v_dst_extent))); + + /* "View.MemoryView":1155 + * + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) + */ + goto __pyx_L4; + } + + /* "View.MemoryView":1159 + * memcpy(dst_data, src_data, itemsize * dst_extent) + * else: + * for i in range(dst_extent): # <<<<<<<<<<<<<< + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride + */ + /*else*/ { + __pyx_t_4 = __pyx_v_dst_extent; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1160 + * else: + * for i in range(dst_extent): + * memcpy(dst_data, src_data, itemsize) # <<<<<<<<<<<<<< + * src_data += src_stride + * dst_data += dst_stride + */ + (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, __pyx_v_itemsize)); + + /* "View.MemoryView":1161 + * for i in range(dst_extent): + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride # <<<<<<<<<<<<<< + * dst_data += dst_stride + * else: + */ + __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); + + /* "View.MemoryView":1162 + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride + * dst_data += dst_stride # <<<<<<<<<<<<<< + * else: + * for i in range(dst_extent): + */ + __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); + } + } + __pyx_L4:; + + /* "View.MemoryView":1154 + * cdef Py_ssize_t dst_stride = dst_strides[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1164 + * dst_data += dst_stride + * else: + * for i in range(dst_extent): # <<<<<<<<<<<<<< + * _copy_strided_to_strided(src_data, src_strides + 1, + * dst_data, dst_strides + 1, + */ + /*else*/ { + __pyx_t_4 = __pyx_v_dst_extent; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1165 + * else: + * for i in range(dst_extent): + * _copy_strided_to_strided(src_data, src_strides + 1, # <<<<<<<<<<<<<< + * dst_data, dst_strides + 1, + * src_shape + 1, dst_shape + 1, + */ + _copy_strided_to_strided(__pyx_v_src_data, (__pyx_v_src_strides + 1), __pyx_v_dst_data, (__pyx_v_dst_strides + 1), (__pyx_v_src_shape + 1), (__pyx_v_dst_shape + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize); + + /* "View.MemoryView":1169 + * src_shape + 1, dst_shape + 1, + * ndim - 1, itemsize) + * src_data += src_stride # <<<<<<<<<<<<<< + * dst_data += dst_stride + * + */ + __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); + + /* "View.MemoryView":1170 + * ndim - 1, itemsize) + * src_data += src_stride + * dst_data += dst_stride # <<<<<<<<<<<<<< + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, + */ + __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); + } + } + __pyx_L3:; + + /* "View.MemoryView":1142 + * + * @cython.cdivision(True) + * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< + * char *dst_data, Py_ssize_t *dst_strides, + * Py_ssize_t *src_shape, Py_ssize_t *dst_shape, + */ + + /* function exit code */ +} + +/* "View.MemoryView":1172 + * dst_data += dst_stride + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) nogil: + */ + +static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize) { + + /* "View.MemoryView":1175 + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) nogil: + * _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides, # <<<<<<<<<<<<<< + * src.shape, dst.shape, ndim, itemsize) + * + */ + _copy_strided_to_strided(__pyx_v_src->data, __pyx_v_src->strides, __pyx_v_dst->data, __pyx_v_dst->strides, __pyx_v_src->shape, __pyx_v_dst->shape, __pyx_v_ndim, __pyx_v_itemsize); + + /* "View.MemoryView":1172 + * dst_data += dst_stride + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1179 + * + * @cname('__pyx_memoryview_slice_get_size') + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< + * "Return the size of the memory occupied by the slice in number of bytes" + * cdef Py_ssize_t shape, size = src.memview.view.itemsize + */ + +static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_src, int __pyx_v_ndim) { + Py_ssize_t __pyx_v_shape; + Py_ssize_t __pyx_v_size; + Py_ssize_t __pyx_r; + Py_ssize_t __pyx_t_1; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + + /* "View.MemoryView":1181 + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: + * "Return the size of the memory occupied by the slice in number of bytes" + * cdef Py_ssize_t shape, size = src.memview.view.itemsize # <<<<<<<<<<<<<< + * + * for shape in src.shape[:ndim]: + */ + __pyx_t_1 = __pyx_v_src->memview->view.itemsize; + __pyx_v_size = __pyx_t_1; + + /* "View.MemoryView":1183 + * cdef Py_ssize_t shape, size = src.memview.view.itemsize + * + * for shape in src.shape[:ndim]: # <<<<<<<<<<<<<< + * size *= shape + * + */ + __pyx_t_3 = (__pyx_v_src->shape + __pyx_v_ndim); + for (__pyx_t_4 = __pyx_v_src->shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { + __pyx_t_2 = __pyx_t_4; + __pyx_v_shape = (__pyx_t_2[0]); + + /* "View.MemoryView":1184 + * + * for shape in src.shape[:ndim]: + * size *= shape # <<<<<<<<<<<<<< + * + * return size + */ + __pyx_v_size = (__pyx_v_size * __pyx_v_shape); + } + + /* "View.MemoryView":1186 + * size *= shape + * + * return size # <<<<<<<<<<<<<< + * + * @cname('__pyx_fill_contig_strides_array') + */ + __pyx_r = __pyx_v_size; + goto __pyx_L0; + + /* "View.MemoryView":1179 + * + * @cname('__pyx_memoryview_slice_get_size') + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< + * "Return the size of the memory occupied by the slice in number of bytes" + * cdef Py_ssize_t shape, size = src.memview.view.itemsize + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1189 + * + * @cname('__pyx_fill_contig_strides_array') + * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< + * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, + * int ndim, char order) nogil: + */ + +static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, Py_ssize_t __pyx_v_stride, int __pyx_v_ndim, char __pyx_v_order) { + int __pyx_v_idx; + Py_ssize_t __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + + /* "View.MemoryView":1198 + * cdef int idx + * + * if order == 'F': # <<<<<<<<<<<<<< + * for idx in range(ndim): + * strides[idx] = stride + */ + __pyx_t_1 = ((__pyx_v_order == 'F') != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1199 + * + * if order == 'F': + * for idx in range(ndim): # <<<<<<<<<<<<<< + * strides[idx] = stride + * stride *= shape[idx] + */ + __pyx_t_2 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_idx = __pyx_t_4; + + /* "View.MemoryView":1200 + * if order == 'F': + * for idx in range(ndim): + * strides[idx] = stride # <<<<<<<<<<<<<< + * stride *= shape[idx] + * else: + */ + (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; + + /* "View.MemoryView":1201 + * for idx in range(ndim): + * strides[idx] = stride + * stride *= shape[idx] # <<<<<<<<<<<<<< + * else: + * for idx in range(ndim - 1, -1, -1): + */ + __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); + } + + /* "View.MemoryView":1198 + * cdef int idx + * + * if order == 'F': # <<<<<<<<<<<<<< + * for idx in range(ndim): + * strides[idx] = stride + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1203 + * stride *= shape[idx] + * else: + * for idx in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< + * strides[idx] = stride + * stride *= shape[idx] + */ + /*else*/ { + for (__pyx_t_2 = (__pyx_v_ndim - 1); __pyx_t_2 > -1; __pyx_t_2-=1) { + __pyx_v_idx = __pyx_t_2; + + /* "View.MemoryView":1204 + * else: + * for idx in range(ndim - 1, -1, -1): + * strides[idx] = stride # <<<<<<<<<<<<<< + * stride *= shape[idx] + * + */ + (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; + + /* "View.MemoryView":1205 + * for idx in range(ndim - 1, -1, -1): + * strides[idx] = stride + * stride *= shape[idx] # <<<<<<<<<<<<<< + * + * return stride + */ + __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); + } + } + __pyx_L3:; + + /* "View.MemoryView":1207 + * stride *= shape[idx] + * + * return stride # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_data_to_temp') + */ + __pyx_r = __pyx_v_stride; + goto __pyx_L0; + + /* "View.MemoryView":1189 + * + * @cname('__pyx_fill_contig_strides_array') + * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< + * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, + * int ndim, char order) nogil: + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1210 + * + * @cname('__pyx_memoryview_copy_data_to_temp') + * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *tmpslice, + * char order, + */ + +static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_tmpslice, char __pyx_v_order, int __pyx_v_ndim) { + int __pyx_v_i; + void *__pyx_v_result; + size_t __pyx_v_itemsize; + size_t __pyx_v_size; + void *__pyx_r; + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + struct __pyx_memoryview_obj *__pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":1221 + * cdef void *result + * + * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< + * cdef size_t size = slice_get_size(src, ndim) + * + */ + __pyx_t_1 = __pyx_v_src->memview->view.itemsize; + __pyx_v_itemsize = __pyx_t_1; + + /* "View.MemoryView":1222 + * + * cdef size_t itemsize = src.memview.view.itemsize + * cdef size_t size = slice_get_size(src, ndim) # <<<<<<<<<<<<<< + * + * result = malloc(size) + */ + __pyx_v_size = __pyx_memoryview_slice_get_size(__pyx_v_src, __pyx_v_ndim); + + /* "View.MemoryView":1224 + * cdef size_t size = slice_get_size(src, ndim) + * + * result = malloc(size) # <<<<<<<<<<<<<< + * if not result: + * _err(MemoryError, NULL) + */ + __pyx_v_result = malloc(__pyx_v_size); + + /* "View.MemoryView":1225 + * + * result = malloc(size) + * if not result: # <<<<<<<<<<<<<< + * _err(MemoryError, NULL) + * + */ + __pyx_t_2 = ((!(__pyx_v_result != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1226 + * result = malloc(size) + * if not result: + * _err(MemoryError, NULL) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_memoryview_err(__pyx_builtin_MemoryError, NULL); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 1226, __pyx_L1_error) + + /* "View.MemoryView":1225 + * + * result = malloc(size) + * if not result: # <<<<<<<<<<<<<< + * _err(MemoryError, NULL) + * + */ + } + + /* "View.MemoryView":1229 + * + * + * tmpslice.data = result # <<<<<<<<<<<<<< + * tmpslice.memview = src.memview + * for i in range(ndim): + */ + __pyx_v_tmpslice->data = ((char *)__pyx_v_result); + + /* "View.MemoryView":1230 + * + * tmpslice.data = result + * tmpslice.memview = src.memview # <<<<<<<<<<<<<< + * for i in range(ndim): + * tmpslice.shape[i] = src.shape[i] + */ + __pyx_t_4 = __pyx_v_src->memview; + __pyx_v_tmpslice->memview = __pyx_t_4; + + /* "View.MemoryView":1231 + * tmpslice.data = result + * tmpslice.memview = src.memview + * for i in range(ndim): # <<<<<<<<<<<<<< + * tmpslice.shape[i] = src.shape[i] + * tmpslice.suboffsets[i] = -1 + */ + __pyx_t_3 = __pyx_v_ndim; + __pyx_t_5 = __pyx_t_3; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1232 + * tmpslice.memview = src.memview + * for i in range(ndim): + * tmpslice.shape[i] = src.shape[i] # <<<<<<<<<<<<<< + * tmpslice.suboffsets[i] = -1 + * + */ + (__pyx_v_tmpslice->shape[__pyx_v_i]) = (__pyx_v_src->shape[__pyx_v_i]); + + /* "View.MemoryView":1233 + * for i in range(ndim): + * tmpslice.shape[i] = src.shape[i] + * tmpslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< + * + * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, + */ + (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L; + } + + /* "View.MemoryView":1235 + * tmpslice.suboffsets[i] = -1 + * + * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, # <<<<<<<<<<<<<< + * ndim, order) + * + */ + (void)(__pyx_fill_contig_strides_array((&(__pyx_v_tmpslice->shape[0])), (&(__pyx_v_tmpslice->strides[0])), __pyx_v_itemsize, __pyx_v_ndim, __pyx_v_order)); + + /* "View.MemoryView":1239 + * + * + * for i in range(ndim): # <<<<<<<<<<<<<< + * if tmpslice.shape[i] == 1: + * tmpslice.strides[i] = 0 + */ + __pyx_t_3 = __pyx_v_ndim; + __pyx_t_5 = __pyx_t_3; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1240 + * + * for i in range(ndim): + * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< + * tmpslice.strides[i] = 0 + * + */ + __pyx_t_2 = (((__pyx_v_tmpslice->shape[__pyx_v_i]) == 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1241 + * for i in range(ndim): + * if tmpslice.shape[i] == 1: + * tmpslice.strides[i] = 0 # <<<<<<<<<<<<<< + * + * if slice_is_contig(src[0], order, ndim): + */ + (__pyx_v_tmpslice->strides[__pyx_v_i]) = 0; + + /* "View.MemoryView":1240 + * + * for i in range(ndim): + * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< + * tmpslice.strides[i] = 0 + * + */ + } + } + + /* "View.MemoryView":1243 + * tmpslice.strides[i] = 0 + * + * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< + * memcpy(result, src.data, size) + * else: + */ + __pyx_t_2 = (__pyx_memviewslice_is_contig((__pyx_v_src[0]), __pyx_v_order, __pyx_v_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1244 + * + * if slice_is_contig(src[0], order, ndim): + * memcpy(result, src.data, size) # <<<<<<<<<<<<<< + * else: + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) + */ + (void)(memcpy(__pyx_v_result, __pyx_v_src->data, __pyx_v_size)); + + /* "View.MemoryView":1243 + * tmpslice.strides[i] = 0 + * + * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< + * memcpy(result, src.data, size) + * else: + */ + goto __pyx_L9; + } + + /* "View.MemoryView":1246 + * memcpy(result, src.data, size) + * else: + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) # <<<<<<<<<<<<<< + * + * return result + */ + /*else*/ { + copy_strided_to_strided(__pyx_v_src, __pyx_v_tmpslice, __pyx_v_ndim, __pyx_v_itemsize); + } + __pyx_L9:; + + /* "View.MemoryView":1248 + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) + * + * return result # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "View.MemoryView":1210 + * + * @cname('__pyx_memoryview_copy_data_to_temp') + * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *tmpslice, + * char order, + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.copy_data_to_temp", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = NULL; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1253 + * + * @cname('__pyx_memoryview_err_extents') + * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % + */ + +static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent1, Py_ssize_t __pyx_v_extent2) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("_err_extents", 0); + + /* "View.MemoryView":1256 + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % + * (i, extent1, extent2)) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_err_dim') + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_extent1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_extent2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + + /* "View.MemoryView":1255 + * cdef int _err_extents(int i, Py_ssize_t extent1, + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % # <<<<<<<<<<<<<< + * (i, extent1, extent2)) + * + */ + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 1255, __pyx_L1_error) + + /* "View.MemoryView":1253 + * + * @cname('__pyx_memoryview_err_extents') + * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView._err_extents", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "View.MemoryView":1259 + * + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii') % dim) + * + */ + +static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, int __pyx_v_dim) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("_err_dim", 0); + __Pyx_INCREF(__pyx_v_error); + + /* "View.MemoryView":1260 + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: + * raise error(msg.decode('ascii') % dim) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_err') + */ + __pyx_t_2 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyUnicode_Format(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_INCREF(__pyx_v_error); + __pyx_t_3 = __pyx_v_error; __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 1260, __pyx_L1_error) + + /* "View.MemoryView":1259 + * + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii') % dim) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView._err_dim", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_XDECREF(__pyx_v_error); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "View.MemoryView":1263 + * + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< + * if msg != NULL: + * raise error(msg.decode('ascii')) + */ + +static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("_err", 0); + __Pyx_INCREF(__pyx_v_error); + + /* "View.MemoryView":1264 + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: + * if msg != NULL: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii')) + * else: + */ + __pyx_t_1 = ((__pyx_v_msg != NULL) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":1265 + * cdef int _err(object error, char *msg) except -1 with gil: + * if msg != NULL: + * raise error(msg.decode('ascii')) # <<<<<<<<<<<<<< + * else: + * raise error + */ + __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_error); + __pyx_t_4 = __pyx_v_error; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 1265, __pyx_L1_error) + + /* "View.MemoryView":1264 + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: + * if msg != NULL: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii')) + * else: + */ + } + + /* "View.MemoryView":1267 + * raise error(msg.decode('ascii')) + * else: + * raise error # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_contents') + */ + /*else*/ { + __Pyx_Raise(__pyx_v_error, 0, 0, 0); + __PYX_ERR(1, 1267, __pyx_L1_error) + } + + /* "View.MemoryView":1263 + * + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< + * if msg != NULL: + * raise error(msg.decode('ascii')) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView._err", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_XDECREF(__pyx_v_error); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "View.MemoryView":1270 + * + * @cname('__pyx_memoryview_copy_contents') + * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice dst, + * int src_ndim, int dst_ndim, + */ + +static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_memviewslice __pyx_v_dst, int __pyx_v_src_ndim, int __pyx_v_dst_ndim, int __pyx_v_dtype_is_object) { + void *__pyx_v_tmpdata; + size_t __pyx_v_itemsize; + int __pyx_v_i; + char __pyx_v_order; + int __pyx_v_broadcasting; + int __pyx_v_direct_copy; + __Pyx_memviewslice __pyx_v_tmp; + int __pyx_v_ndim; + int __pyx_r; + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + void *__pyx_t_7; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":1278 + * Check for overlapping memory and verify the shapes. + * """ + * cdef void *tmpdata = NULL # <<<<<<<<<<<<<< + * cdef size_t itemsize = src.memview.view.itemsize + * cdef int i + */ + __pyx_v_tmpdata = NULL; + + /* "View.MemoryView":1279 + * """ + * cdef void *tmpdata = NULL + * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) + */ + __pyx_t_1 = __pyx_v_src.memview->view.itemsize; + __pyx_v_itemsize = __pyx_t_1; + + /* "View.MemoryView":1281 + * cdef size_t itemsize = src.memview.view.itemsize + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) # <<<<<<<<<<<<<< + * cdef bint broadcasting = False + * cdef bint direct_copy = False + */ + __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_src), __pyx_v_src_ndim); + + /* "View.MemoryView":1282 + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) + * cdef bint broadcasting = False # <<<<<<<<<<<<<< + * cdef bint direct_copy = False + * cdef __Pyx_memviewslice tmp + */ + __pyx_v_broadcasting = 0; + + /* "View.MemoryView":1283 + * cdef char order = get_best_order(&src, src_ndim) + * cdef bint broadcasting = False + * cdef bint direct_copy = False # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice tmp + * + */ + __pyx_v_direct_copy = 0; + + /* "View.MemoryView":1286 + * cdef __Pyx_memviewslice tmp + * + * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: + */ + __pyx_t_2 = ((__pyx_v_src_ndim < __pyx_v_dst_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1287 + * + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) # <<<<<<<<<<<<<< + * elif dst_ndim < src_ndim: + * broadcast_leading(&dst, dst_ndim, src_ndim) + */ + __pyx_memoryview_broadcast_leading((&__pyx_v_src), __pyx_v_src_ndim, __pyx_v_dst_ndim); + + /* "View.MemoryView":1286 + * cdef __Pyx_memviewslice tmp + * + * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1288 + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&dst, dst_ndim, src_ndim) + * + */ + __pyx_t_2 = ((__pyx_v_dst_ndim < __pyx_v_src_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1289 + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: + * broadcast_leading(&dst, dst_ndim, src_ndim) # <<<<<<<<<<<<<< + * + * cdef int ndim = max(src_ndim, dst_ndim) + */ + __pyx_memoryview_broadcast_leading((&__pyx_v_dst), __pyx_v_dst_ndim, __pyx_v_src_ndim); + + /* "View.MemoryView":1288 + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&dst, dst_ndim, src_ndim) + * + */ + } + __pyx_L3:; + + /* "View.MemoryView":1291 + * broadcast_leading(&dst, dst_ndim, src_ndim) + * + * cdef int ndim = max(src_ndim, dst_ndim) # <<<<<<<<<<<<<< + * + * for i in range(ndim): + */ + __pyx_t_3 = __pyx_v_dst_ndim; + __pyx_t_4 = __pyx_v_src_ndim; + if (((__pyx_t_3 > __pyx_t_4) != 0)) { + __pyx_t_5 = __pyx_t_3; + } else { + __pyx_t_5 = __pyx_t_4; + } + __pyx_v_ndim = __pyx_t_5; + + /* "View.MemoryView":1293 + * cdef int ndim = max(src_ndim, dst_ndim) + * + * for i in range(ndim): # <<<<<<<<<<<<<< + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: + */ + __pyx_t_5 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_5; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1294 + * + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< + * if src.shape[i] == 1: + * broadcasting = True + */ + __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) != (__pyx_v_dst.shape[__pyx_v_i])) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1295 + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: # <<<<<<<<<<<<<< + * broadcasting = True + * src.strides[i] = 0 + */ + __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) == 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1296 + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: + * broadcasting = True # <<<<<<<<<<<<<< + * src.strides[i] = 0 + * else: + */ + __pyx_v_broadcasting = 1; + + /* "View.MemoryView":1297 + * if src.shape[i] == 1: + * broadcasting = True + * src.strides[i] = 0 # <<<<<<<<<<<<<< + * else: + * _err_extents(i, dst.shape[i], src.shape[i]) + */ + (__pyx_v_src.strides[__pyx_v_i]) = 0; + + /* "View.MemoryView":1295 + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: # <<<<<<<<<<<<<< + * broadcasting = True + * src.strides[i] = 0 + */ + goto __pyx_L7; + } + + /* "View.MemoryView":1299 + * src.strides[i] = 0 + * else: + * _err_extents(i, dst.shape[i], src.shape[i]) # <<<<<<<<<<<<<< + * + * if src.suboffsets[i] >= 0: + */ + /*else*/ { + __pyx_t_6 = __pyx_memoryview_err_extents(__pyx_v_i, (__pyx_v_dst.shape[__pyx_v_i]), (__pyx_v_src.shape[__pyx_v_i])); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1299, __pyx_L1_error) + } + __pyx_L7:; + + /* "View.MemoryView":1294 + * + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< + * if src.shape[i] == 1: + * broadcasting = True + */ + } + + /* "View.MemoryView":1301 + * _err_extents(i, dst.shape[i], src.shape[i]) + * + * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + */ + __pyx_t_2 = (((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1302 + * + * if src.suboffsets[i] >= 0: + * _err_dim(ValueError, "Dimension %d is not direct", i) # <<<<<<<<<<<<<< + * + * if slices_overlap(&src, &dst, ndim, itemsize): + */ + __pyx_t_6 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Dimension %d is not direct"), __pyx_v_i); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1302, __pyx_L1_error) + + /* "View.MemoryView":1301 + * _err_extents(i, dst.shape[i], src.shape[i]) + * + * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + */ + } + } + + /* "View.MemoryView":1304 + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< + * + * if not slice_is_contig(src, order, ndim): + */ + __pyx_t_2 = (__pyx_slices_overlap((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1306 + * if slices_overlap(&src, &dst, ndim, itemsize): + * + * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< + * order = get_best_order(&dst, ndim) + * + */ + __pyx_t_2 = ((!(__pyx_memviewslice_is_contig(__pyx_v_src, __pyx_v_order, __pyx_v_ndim) != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1307 + * + * if not slice_is_contig(src, order, ndim): + * order = get_best_order(&dst, ndim) # <<<<<<<<<<<<<< + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) + */ + __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim); + + /* "View.MemoryView":1306 + * if slices_overlap(&src, &dst, ndim, itemsize): + * + * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< + * order = get_best_order(&dst, ndim) + * + */ + } + + /* "View.MemoryView":1309 + * order = get_best_order(&dst, ndim) + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) # <<<<<<<<<<<<<< + * src = tmp + * + */ + __pyx_t_7 = __pyx_memoryview_copy_data_to_temp((&__pyx_v_src), (&__pyx_v_tmp), __pyx_v_order, __pyx_v_ndim); if (unlikely(__pyx_t_7 == ((void *)NULL))) __PYX_ERR(1, 1309, __pyx_L1_error) + __pyx_v_tmpdata = __pyx_t_7; + + /* "View.MemoryView":1310 + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) + * src = tmp # <<<<<<<<<<<<<< + * + * if not broadcasting: + */ + __pyx_v_src = __pyx_v_tmp; + + /* "View.MemoryView":1304 + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< + * + * if not slice_is_contig(src, order, ndim): + */ + } + + /* "View.MemoryView":1312 + * src = tmp + * + * if not broadcasting: # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = ((!(__pyx_v_broadcasting != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1315 + * + * + * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): + */ + __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'C', __pyx_v_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1316 + * + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) # <<<<<<<<<<<<<< + * elif slice_is_contig(src, 'F', ndim): + * direct_copy = slice_is_contig(dst, 'F', ndim) + */ + __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'C', __pyx_v_ndim); + + /* "View.MemoryView":1315 + * + * + * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): + */ + goto __pyx_L12; + } + + /* "View.MemoryView":1317 + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + */ + __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'F', __pyx_v_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1318 + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): + * direct_copy = slice_is_contig(dst, 'F', ndim) # <<<<<<<<<<<<<< + * + * if direct_copy: + */ + __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'F', __pyx_v_ndim); + + /* "View.MemoryView":1317 + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + */ + } + __pyx_L12:; + + /* "View.MemoryView":1320 + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + * if direct_copy: # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + __pyx_t_2 = (__pyx_v_direct_copy != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1322 + * if direct_copy: + * + * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1323 + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, True) + * free(tmpdata) + */ + (void)(memcpy(__pyx_v_dst.data, __pyx_v_src.data, __pyx_memoryview_slice_get_size((&__pyx_v_src), __pyx_v_ndim))); + + /* "View.MemoryView":1324 + * refcount_copying(&dst, dtype_is_object, ndim, False) + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * free(tmpdata) + * return 0 + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1325 + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) + * free(tmpdata) # <<<<<<<<<<<<<< + * return 0 + * + */ + free(__pyx_v_tmpdata); + + /* "View.MemoryView":1326 + * refcount_copying(&dst, dtype_is_object, ndim, True) + * free(tmpdata) + * return 0 # <<<<<<<<<<<<<< + * + * if order == 'F' == get_best_order(&dst, ndim): + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":1320 + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + * if direct_copy: # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + } + + /* "View.MemoryView":1312 + * src = tmp + * + * if not broadcasting: # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":1328 + * return 0 + * + * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = (__pyx_v_order == 'F'); + if (__pyx_t_2) { + __pyx_t_2 = ('F' == __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim)); + } + __pyx_t_8 = (__pyx_t_2 != 0); + if (__pyx_t_8) { + + /* "View.MemoryView":1331 + * + * + * transpose_memslice(&src) # <<<<<<<<<<<<<< + * transpose_memslice(&dst) + * + */ + __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_src)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1331, __pyx_L1_error) + + /* "View.MemoryView":1332 + * + * transpose_memslice(&src) + * transpose_memslice(&dst) # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_dst)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1332, __pyx_L1_error) + + /* "View.MemoryView":1328 + * return 0 + * + * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":1334 + * transpose_memslice(&dst) + * + * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * copy_strided_to_strided(&src, &dst, ndim, itemsize) + * refcount_copying(&dst, dtype_is_object, ndim, True) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1335 + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + * copy_strided_to_strided(&src, &dst, ndim, itemsize) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, True) + * + */ + copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); + + /* "View.MemoryView":1336 + * refcount_copying(&dst, dtype_is_object, ndim, False) + * copy_strided_to_strided(&src, &dst, ndim, itemsize) + * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * + * free(tmpdata) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1338 + * refcount_copying(&dst, dtype_is_object, ndim, True) + * + * free(tmpdata) # <<<<<<<<<<<<<< + * return 0 + * + */ + free(__pyx_v_tmpdata); + + /* "View.MemoryView":1339 + * + * free(tmpdata) + * return 0 # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_broadcast_leading') + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":1270 + * + * @cname('__pyx_memoryview_copy_contents') + * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice dst, + * int src_ndim, int dst_ndim, + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.memoryview_copy_contents", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1342 + * + * @cname('__pyx_memoryview_broadcast_leading') + * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< + * int ndim, + * int ndim_other) nogil: + */ + +static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim, int __pyx_v_ndim_other) { + int __pyx_v_i; + int __pyx_v_offset; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + + /* "View.MemoryView":1346 + * int ndim_other) nogil: + * cdef int i + * cdef int offset = ndim_other - ndim # <<<<<<<<<<<<<< + * + * for i in range(ndim - 1, -1, -1): + */ + __pyx_v_offset = (__pyx_v_ndim_other - __pyx_v_ndim); + + /* "View.MemoryView":1348 + * cdef int offset = ndim_other - ndim + * + * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = mslice.strides[i] + */ + for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { + __pyx_v_i = __pyx_t_1; + + /* "View.MemoryView":1349 + * + * for i in range(ndim - 1, -1, -1): + * mslice.shape[i + offset] = mslice.shape[i] # <<<<<<<<<<<<<< + * mslice.strides[i + offset] = mslice.strides[i] + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] + */ + (__pyx_v_mslice->shape[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->shape[__pyx_v_i]); + + /* "View.MemoryView":1350 + * for i in range(ndim - 1, -1, -1): + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = mslice.strides[i] # <<<<<<<<<<<<<< + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] + * + */ + (__pyx_v_mslice->strides[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->strides[__pyx_v_i]); + + /* "View.MemoryView":1351 + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = mslice.strides[i] + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] # <<<<<<<<<<<<<< + * + * for i in range(offset): + */ + (__pyx_v_mslice->suboffsets[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->suboffsets[__pyx_v_i]); + } + + /* "View.MemoryView":1353 + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] + * + * for i in range(offset): # <<<<<<<<<<<<<< + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] + */ + __pyx_t_1 = __pyx_v_offset; + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_i = __pyx_t_3; + + /* "View.MemoryView":1354 + * + * for i in range(offset): + * mslice.shape[i] = 1 # <<<<<<<<<<<<<< + * mslice.strides[i] = mslice.strides[0] + * mslice.suboffsets[i] = -1 + */ + (__pyx_v_mslice->shape[__pyx_v_i]) = 1; + + /* "View.MemoryView":1355 + * for i in range(offset): + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] # <<<<<<<<<<<<<< + * mslice.suboffsets[i] = -1 + * + */ + (__pyx_v_mslice->strides[__pyx_v_i]) = (__pyx_v_mslice->strides[0]); + + /* "View.MemoryView":1356 + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] + * mslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< + * + * + */ + (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L; + } + + /* "View.MemoryView":1342 + * + * @cname('__pyx_memoryview_broadcast_leading') + * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< + * int ndim, + * int ndim_other) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1364 + * + * @cname('__pyx_memoryview_refcount_copying') + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< + * int ndim, bint inc) nogil: + * + */ + +static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_dtype_is_object, int __pyx_v_ndim, int __pyx_v_inc) { + int __pyx_t_1; + + /* "View.MemoryView":1368 + * + * + * if dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, + * dst.strides, ndim, inc) + */ + __pyx_t_1 = (__pyx_v_dtype_is_object != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1369 + * + * if dtype_is_object: + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, # <<<<<<<<<<<<<< + * dst.strides, ndim, inc) + * + */ + __pyx_memoryview_refcount_objects_in_slice_with_gil(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_inc); + + /* "View.MemoryView":1368 + * + * + * if dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, + * dst.strides, ndim, inc) + */ + } + + /* "View.MemoryView":1364 + * + * @cname('__pyx_memoryview_refcount_copying') + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< + * int ndim, bint inc) nogil: + * + */ + + /* function exit code */ +} + +/* "View.MemoryView":1373 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') + * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * bint inc) with gil: + */ + +static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { + __Pyx_RefNannyDeclarations + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("refcount_objects_in_slice_with_gil", 0); + + /* "View.MemoryView":1376 + * Py_ssize_t *strides, int ndim, + * bint inc) with gil: + * refcount_objects_in_slice(data, shape, strides, ndim, inc) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') + */ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, __pyx_v_shape, __pyx_v_strides, __pyx_v_ndim, __pyx_v_inc); + + /* "View.MemoryView":1373 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') + * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * bint inc) with gil: + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif +} + +/* "View.MemoryView":1379 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') + * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, bint inc): + * cdef Py_ssize_t i + */ + +static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + __Pyx_RefNannySetupContext("refcount_objects_in_slice", 0); + + /* "View.MemoryView":1383 + * cdef Py_ssize_t i + * + * for i in range(shape[0]): # <<<<<<<<<<<<<< + * if ndim == 1: + * if inc: + */ + __pyx_t_1 = (__pyx_v_shape[0]); + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_i = __pyx_t_3; + + /* "View.MemoryView":1384 + * + * for i in range(shape[0]): + * if ndim == 1: # <<<<<<<<<<<<<< + * if inc: + * Py_INCREF(( data)[0]) + */ + __pyx_t_4 = ((__pyx_v_ndim == 1) != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":1385 + * for i in range(shape[0]): + * if ndim == 1: + * if inc: # <<<<<<<<<<<<<< + * Py_INCREF(( data)[0]) + * else: + */ + __pyx_t_4 = (__pyx_v_inc != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":1386 + * if ndim == 1: + * if inc: + * Py_INCREF(( data)[0]) # <<<<<<<<<<<<<< + * else: + * Py_DECREF(( data)[0]) + */ + Py_INCREF((((PyObject **)__pyx_v_data)[0])); + + /* "View.MemoryView":1385 + * for i in range(shape[0]): + * if ndim == 1: + * if inc: # <<<<<<<<<<<<<< + * Py_INCREF(( data)[0]) + * else: + */ + goto __pyx_L6; + } + + /* "View.MemoryView":1388 + * Py_INCREF(( data)[0]) + * else: + * Py_DECREF(( data)[0]) # <<<<<<<<<<<<<< + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, + */ + /*else*/ { + Py_DECREF((((PyObject **)__pyx_v_data)[0])); + } + __pyx_L6:; + + /* "View.MemoryView":1384 + * + * for i in range(shape[0]): + * if ndim == 1: # <<<<<<<<<<<<<< + * if inc: + * Py_INCREF(( data)[0]) + */ + goto __pyx_L5; + } + + /* "View.MemoryView":1390 + * Py_DECREF(( data)[0]) + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< + * ndim - 1, inc) + * + */ + /*else*/ { + + /* "View.MemoryView":1391 + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, + * ndim - 1, inc) # <<<<<<<<<<<<<< + * + * data += strides[0] + */ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_inc); + } + __pyx_L5:; + + /* "View.MemoryView":1393 + * ndim - 1, inc) + * + * data += strides[0] # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_data = (__pyx_v_data + (__pyx_v_strides[0])); + } + + /* "View.MemoryView":1379 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') + * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, bint inc): + * cdef Py_ssize_t i + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":1399 + * + * @cname('__pyx_memoryview_slice_assign_scalar') + * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< + * size_t itemsize, void *item, + * bint dtype_is_object) nogil: + */ + +static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item, int __pyx_v_dtype_is_object) { + + /* "View.MemoryView":1402 + * size_t itemsize, void *item, + * bint dtype_is_object) nogil: + * refcount_copying(dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, + * itemsize, item) + */ + __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1403 + * bint dtype_is_object) nogil: + * refcount_copying(dst, dtype_is_object, ndim, False) + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, # <<<<<<<<<<<<<< + * itemsize, item) + * refcount_copying(dst, dtype_is_object, ndim, True) + */ + __pyx_memoryview__slice_assign_scalar(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_itemsize, __pyx_v_item); + + /* "View.MemoryView":1405 + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, + * itemsize, item) + * refcount_copying(dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * + * + */ + __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1399 + * + * @cname('__pyx_memoryview_slice_assign_scalar') + * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< + * size_t itemsize, void *item, + * bint dtype_is_object) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1409 + * + * @cname('__pyx_memoryview__slice_assign_scalar') + * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * size_t itemsize, void *item) nogil: + */ + +static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + Py_ssize_t __pyx_v_stride; + Py_ssize_t __pyx_v_extent; + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + + /* "View.MemoryView":1413 + * size_t itemsize, void *item) nogil: + * cdef Py_ssize_t i + * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t extent = shape[0] + * + */ + __pyx_v_stride = (__pyx_v_strides[0]); + + /* "View.MemoryView":1414 + * cdef Py_ssize_t i + * cdef Py_ssize_t stride = strides[0] + * cdef Py_ssize_t extent = shape[0] # <<<<<<<<<<<<<< + * + * if ndim == 1: + */ + __pyx_v_extent = (__pyx_v_shape[0]); + + /* "View.MemoryView":1416 + * cdef Py_ssize_t extent = shape[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * for i in range(extent): + * memcpy(data, item, itemsize) + */ + __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1417 + * + * if ndim == 1: + * for i in range(extent): # <<<<<<<<<<<<<< + * memcpy(data, item, itemsize) + * data += stride + */ + __pyx_t_2 = __pyx_v_extent; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1418 + * if ndim == 1: + * for i in range(extent): + * memcpy(data, item, itemsize) # <<<<<<<<<<<<<< + * data += stride + * else: + */ + (void)(memcpy(__pyx_v_data, __pyx_v_item, __pyx_v_itemsize)); + + /* "View.MemoryView":1419 + * for i in range(extent): + * memcpy(data, item, itemsize) + * data += stride # <<<<<<<<<<<<<< + * else: + * for i in range(extent): + */ + __pyx_v_data = (__pyx_v_data + __pyx_v_stride); + } + + /* "View.MemoryView":1416 + * cdef Py_ssize_t extent = shape[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * for i in range(extent): + * memcpy(data, item, itemsize) + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1421 + * data += stride + * else: + * for i in range(extent): # <<<<<<<<<<<<<< + * _slice_assign_scalar(data, shape + 1, strides + 1, + * ndim - 1, itemsize, item) + */ + /*else*/ { + __pyx_t_2 = __pyx_v_extent; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1422 + * else: + * for i in range(extent): + * _slice_assign_scalar(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< + * ndim - 1, itemsize, item) + * data += stride + */ + __pyx_memoryview__slice_assign_scalar(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize, __pyx_v_item); + + /* "View.MemoryView":1424 + * _slice_assign_scalar(data, shape + 1, strides + 1, + * ndim - 1, itemsize, item) + * data += stride # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_data = (__pyx_v_data + __pyx_v_stride); + } + } + __pyx_L3:; + + /* "View.MemoryView":1409 + * + * @cname('__pyx_memoryview__slice_assign_scalar') + * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * size_t itemsize, void *item) nogil: + */ + + /* function exit code */ +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum = {"__pyx_unpickle_Enum", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Enum") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 0); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__24, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError); + __pyx_t_4 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) # <<<<<<<<<<<<<< + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_INCREF(__pyx_v___pyx_PickleError); + __pyx_t_1 = __pyx_v___pyx_PickleError; __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_MemviewEnum_type), __pyx_n_s_new); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v___pyx_type); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result = __pyx_t_4; + __pyx_t_4 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_3 = (__pyx_v___pyx_state != Py_None); + __pyx_t_2 = (__pyx_t_3 != 0); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||((void)PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 9, __pyx_L1_error) + __pyx_t_4 = __pyx_unpickle_Enum__set_state(((struct __pyx_MemviewEnum_obj *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 0); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->name); + __Pyx_DECREF(__pyx_v___pyx_result->name); + __pyx_v___pyx_result->name = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 13, __pyx_L1_error) + } + __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_4 = ((__pyx_t_3 > 1) != 0); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_4 != 0); + __pyx_t_2 = __pyx_t_5; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 14, __pyx_L1_error) + } + __pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static struct __pyx_vtabstruct_array __pyx_vtable_array; + +static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_array_obj *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_array_obj *)o); + p->__pyx_vtab = __pyx_vtabptr_array; + p->mode = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_format = ((PyObject*)Py_None); Py_INCREF(Py_None); + if (unlikely(__pyx_array___cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_array(PyObject *o) { + struct __pyx_array_obj *p = (struct __pyx_array_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_array___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->mode); + Py_CLEAR(p->_format); + (*Py_TYPE(o)->tp_free)(o); +} +static PyObject *__pyx_sq_item_array(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_array(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_array___setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyObject *__pyx_tp_getattro_array(PyObject *o, PyObject *n) { + PyObject *v = __Pyx_PyObject_GenericGetAttr(o, n); + if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + v = __pyx_array___getattr__(o, n); + } + return v; +} + +static PyObject *__pyx_getprop___pyx_array_memview(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(o); +} + +static PyMethodDef __pyx_methods_array[] = { + {"__getattr__", (PyCFunction)__pyx_array___getattr__, METH_O|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_array_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_array_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_array[] = { + {(char *)"memview", __pyx_getprop___pyx_array_memview, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_array = { + __pyx_array___len__, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_array, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_array = { + __pyx_array___len__, /*mp_length*/ + __pyx_array___getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_array, /*mp_ass_subscript*/ +}; + +static PyBufferProcs __pyx_tp_as_buffer_array = { + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getreadbuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getwritebuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getsegcount*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getcharbuffer*/ + #endif + __pyx_array_getbuffer, /*bf_getbuffer*/ + 0, /*bf_releasebuffer*/ +}; + +static PyTypeObject __pyx_type___pyx_array = { + PyVarObject_HEAD_INIT(0, 0) + "zoo.board_games.gomoku.envs.get_done_winner_cython.array", /*tp_name*/ + sizeof(struct __pyx_array_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_array, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_array, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_array, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + __pyx_tp_getattro_array, /*tp_getattro*/ + 0, /*tp_setattro*/ + &__pyx_tp_as_buffer_array, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_array, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_array, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_array, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + 0, /*tp_pypy_flags*/ + #endif +}; + +static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_MemviewEnum_obj *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_MemviewEnum_obj *)o); + p->name = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_Enum(PyObject *o) { + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->name); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_Enum(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + if (p->name) { + e = (*v)(p->name, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_Enum(PyObject *o) { + PyObject* tmp; + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + tmp = ((PyObject*)p->name); + p->name = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyMethodDef __pyx_methods_Enum[] = { + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type___pyx_MemviewEnum = { + PyVarObject_HEAD_INIT(0, 0) + "zoo.board_games.gomoku.envs.get_done_winner_cython.Enum", /*tp_name*/ + sizeof(struct __pyx_MemviewEnum_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_Enum, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_MemviewEnum___repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_Enum, /*tp_traverse*/ + __pyx_tp_clear_Enum, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_Enum, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_MemviewEnum___init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_Enum, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + 0, /*tp_pypy_flags*/ + #endif +}; +static struct __pyx_vtabstruct_memoryview __pyx_vtable_memoryview; + +static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_memoryview_obj *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_memoryview_obj *)o); + p->__pyx_vtab = __pyx_vtabptr_memoryview; + p->obj = Py_None; Py_INCREF(Py_None); + p->_size = Py_None; Py_INCREF(Py_None); + p->_array_interface = Py_None; Py_INCREF(Py_None); + p->view.obj = NULL; + if (unlikely(__pyx_memoryview___cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_memoryview(PyObject *o) { + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_memoryview___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->obj); + Py_CLEAR(p->_size); + Py_CLEAR(p->_array_interface); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_memoryview(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + if (p->obj) { + e = (*v)(p->obj, a); if (e) return e; + } + if (p->_size) { + e = (*v)(p->_size, a); if (e) return e; + } + if (p->_array_interface) { + e = (*v)(p->_array_interface, a); if (e) return e; + } + if (p->view.obj) { + e = (*v)(p->view.obj, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_memoryview(PyObject *o) { + PyObject* tmp; + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + tmp = ((PyObject*)p->obj); + p->obj = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_size); + p->_size = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_array_interface); + p->_array_interface = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + Py_CLEAR(p->view.obj); + return 0; +} +static PyObject *__pyx_sq_item_memoryview(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_memoryview(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_memoryview___setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyObject *__pyx_getprop___pyx_memoryview_T(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_base(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_shape(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_strides(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_suboffsets(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_ndim(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_itemsize(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_nbytes(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_size(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(o); +} + +static PyMethodDef __pyx_methods_memoryview[] = { + {"is_c_contig", (PyCFunction)__pyx_memoryview_is_c_contig, METH_NOARGS, 0}, + {"is_f_contig", (PyCFunction)__pyx_memoryview_is_f_contig, METH_NOARGS, 0}, + {"copy", (PyCFunction)__pyx_memoryview_copy, METH_NOARGS, 0}, + {"copy_fortran", (PyCFunction)__pyx_memoryview_copy_fortran, METH_NOARGS, 0}, + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_memoryview[] = { + {(char *)"T", __pyx_getprop___pyx_memoryview_T, 0, (char *)0, 0}, + {(char *)"base", __pyx_getprop___pyx_memoryview_base, 0, (char *)0, 0}, + {(char *)"shape", __pyx_getprop___pyx_memoryview_shape, 0, (char *)0, 0}, + {(char *)"strides", __pyx_getprop___pyx_memoryview_strides, 0, (char *)0, 0}, + {(char *)"suboffsets", __pyx_getprop___pyx_memoryview_suboffsets, 0, (char *)0, 0}, + {(char *)"ndim", __pyx_getprop___pyx_memoryview_ndim, 0, (char *)0, 0}, + {(char *)"itemsize", __pyx_getprop___pyx_memoryview_itemsize, 0, (char *)0, 0}, + {(char *)"nbytes", __pyx_getprop___pyx_memoryview_nbytes, 0, (char *)0, 0}, + {(char *)"size", __pyx_getprop___pyx_memoryview_size, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_memoryview = { + __pyx_memoryview___len__, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_memoryview, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_memoryview = { + __pyx_memoryview___len__, /*mp_length*/ + __pyx_memoryview___getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_memoryview, /*mp_ass_subscript*/ +}; + +static PyBufferProcs __pyx_tp_as_buffer_memoryview = { + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getreadbuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getwritebuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getsegcount*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getcharbuffer*/ + #endif + __pyx_memoryview_getbuffer, /*bf_getbuffer*/ + 0, /*bf_releasebuffer*/ +}; + +static PyTypeObject __pyx_type___pyx_memoryview = { + PyVarObject_HEAD_INIT(0, 0) + "zoo.board_games.gomoku.envs.get_done_winner_cython.memoryview", /*tp_name*/ + sizeof(struct __pyx_memoryview_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_memoryview, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_memoryview___repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_memoryview, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_memoryview, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + __pyx_memoryview___str__, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + &__pyx_tp_as_buffer_memoryview, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_memoryview, /*tp_traverse*/ + __pyx_tp_clear_memoryview, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_memoryview, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_memoryview, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_memoryview, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + 0, /*tp_pypy_flags*/ + #endif +}; +static struct __pyx_vtabstruct__memoryviewslice __pyx_vtable__memoryviewslice; + +static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_memoryviewslice_obj *p; + PyObject *o = __pyx_tp_new_memoryview(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_memoryviewslice_obj *)o); + p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_memoryview*)__pyx_vtabptr__memoryviewslice; + p->from_object = Py_None; Py_INCREF(Py_None); + p->from_slice.memview = NULL; + return o; +} + +static void __pyx_tp_dealloc__memoryviewslice(PyObject *o) { + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_memoryviewslice___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->from_object); + PyObject_GC_Track(o); + __pyx_tp_dealloc_memoryview(o); +} + +static int __pyx_tp_traverse__memoryviewslice(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + e = __pyx_tp_traverse_memoryview(o, v, a); if (e) return e; + if (p->from_object) { + e = (*v)(p->from_object, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear__memoryviewslice(PyObject *o) { + PyObject* tmp; + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + __pyx_tp_clear_memoryview(o); + tmp = ((PyObject*)p->from_object); + p->from_object = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + __PYX_XDEC_MEMVIEW(&p->from_slice, 1); + return 0; +} + +static PyObject *__pyx_getprop___pyx_memoryviewslice_base(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(o); +} + +static PyMethodDef __pyx_methods__memoryviewslice[] = { + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets__memoryviewslice[] = { + {(char *)"base", __pyx_getprop___pyx_memoryviewslice_base, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type___pyx_memoryviewslice = { + PyVarObject_HEAD_INIT(0, 0) + "zoo.board_games.gomoku.envs.get_done_winner_cython._memoryviewslice", /*tp_name*/ + sizeof(struct __pyx_memoryviewslice_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc__memoryviewslice, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + #if CYTHON_COMPILING_IN_PYPY + __pyx_memoryview___repr__, /*tp_repr*/ + #else + 0, /*tp_repr*/ + #endif + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + #if CYTHON_COMPILING_IN_PYPY + __pyx_memoryview___str__, /*tp_str*/ + #else + 0, /*tp_str*/ + #endif + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + "Internal class for passing memoryview slices to Python", /*tp_doc*/ + __pyx_tp_traverse__memoryviewslice, /*tp_traverse*/ + __pyx_tp_clear__memoryviewslice, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods__memoryviewslice, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets__memoryviewslice, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new__memoryviewslice, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + 0, /*tp_pypy_flags*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {"get_done_winner_cython", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3zoo_11board_games_6gomoku_4envs_22get_done_winner_cython_1get_done_winner_cython, METH_VARARGS|METH_KEYWORDS, __pyx_doc_3zoo_11board_games_6gomoku_4envs_22get_done_winner_cython_get_done_winner_cython}, + {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_get_done_winner_cython(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_get_done_winner_cython}, + {0, NULL} +}; +#endif + +static struct PyModuleDef __pyx_moduledef = { + PyModuleDef_HEAD_INIT, + "get_done_winner_cython", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_ASCII, __pyx_k_ASCII, sizeof(__pyx_k_ASCII), 0, 0, 1, 1}, + {&__pyx_kp_s_Buffer_view_does_not_expose_stri, __pyx_k_Buffer_view_does_not_expose_stri, sizeof(__pyx_k_Buffer_view_does_not_expose_stri), 0, 0, 1, 0}, + {&__pyx_kp_s_Can_only_create_a_buffer_that_is, __pyx_k_Can_only_create_a_buffer_that_is, sizeof(__pyx_k_Can_only_create_a_buffer_that_is), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_assign_to_read_only_memor, __pyx_k_Cannot_assign_to_read_only_memor, sizeof(__pyx_k_Cannot_assign_to_read_only_memor), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_create_writable_memory_vi, __pyx_k_Cannot_create_writable_memory_vi, sizeof(__pyx_k_Cannot_create_writable_memory_vi), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_index_with_type_s, __pyx_k_Cannot_index_with_type_s, sizeof(__pyx_k_Cannot_index_with_type_s), 0, 0, 1, 0}, + {&__pyx_n_s_Ellipsis, __pyx_k_Ellipsis, sizeof(__pyx_k_Ellipsis), 0, 0, 1, 1}, + {&__pyx_kp_s_Empty_shape_tuple_for_cython_arr, __pyx_k_Empty_shape_tuple_for_cython_arr, sizeof(__pyx_k_Empty_shape_tuple_for_cython_arr), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 0, 1, 0}, + {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1}, + {&__pyx_kp_s_Indirect_dimensions_not_supporte, __pyx_k_Indirect_dimensions_not_supporte, sizeof(__pyx_k_Indirect_dimensions_not_supporte), 0, 0, 1, 0}, + {&__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_k_Invalid_mode_expected_c_or_fortr, sizeof(__pyx_k_Invalid_mode_expected_c_or_fortr), 0, 0, 1, 0}, + {&__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_k_Invalid_shape_in_axis_d_d, sizeof(__pyx_k_Invalid_shape_in_axis_d_d), 0, 0, 1, 0}, + {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, + {&__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_k_MemoryView_of_r_at_0x_x, sizeof(__pyx_k_MemoryView_of_r_at_0x_x), 0, 0, 1, 0}, + {&__pyx_kp_s_MemoryView_of_r_object, __pyx_k_MemoryView_of_r_object, sizeof(__pyx_k_MemoryView_of_r_object), 0, 0, 1, 0}, + {&__pyx_n_b_O, __pyx_k_O, sizeof(__pyx_k_O), 0, 0, 0, 1}, + {&__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_k_Out_of_bounds_on_buffer_access_a, sizeof(__pyx_k_Out_of_bounds_on_buffer_access_a), 0, 0, 1, 0}, + {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_kp_s_Unable_to_convert_item_to_object, __pyx_k_Unable_to_convert_item_to_object, sizeof(__pyx_k_Unable_to_convert_item_to_object), 0, 0, 1, 0}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_View_MemoryView, __pyx_k_View_MemoryView, sizeof(__pyx_k_View_MemoryView), 0, 0, 1, 1}, + {&__pyx_n_s_allocate_buffer, __pyx_k_allocate_buffer, sizeof(__pyx_k_allocate_buffer), 0, 0, 1, 1}, + {&__pyx_n_s_base, __pyx_k_base, sizeof(__pyx_k_base), 0, 0, 1, 1}, + {&__pyx_n_s_board, __pyx_k_board, sizeof(__pyx_k_board), 0, 0, 1, 1}, + {&__pyx_n_s_board_size, __pyx_k_board_size, sizeof(__pyx_k_board_size), 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_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_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}, + {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, 25, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 134, __pyx_L1_error) + __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 149, __pyx_L1_error) + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 152, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) + __pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_n_s_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(1, 406, __pyx_L1_error) + __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(1, 615, __pyx_L1_error) + __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 834, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":22 + * cdef int32_t i, j, player, x, y, count + * cdef bint has_legal_actions = False + * cdef directions = ((1, -1), (1, 0), (1, 1), (0, 1)) # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple_ = PyTuple_Pack(2, __pyx_int_1, __pyx_int_neg_1); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + __pyx_tuple__2 = PyTuple_Pack(2, __pyx_int_1, __pyx_int_0); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + __pyx_tuple__3 = PyTuple_Pack(2, __pyx_int_1, __pyx_int_1); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + __pyx_tuple__4 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_1); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + __pyx_tuple__5 = PyTuple_Pack(4, __pyx_tuple_, __pyx_tuple__2, __pyx_tuple__3, __pyx_tuple__4); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 22, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "View.MemoryView":134 + * + * if not self.ndim: + * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< + * + * if itemsize <= 0: + */ + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_Empty_shape_tuple_for_cython_arr); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + + /* "View.MemoryView":137 + * + * if itemsize <= 0: + * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< + * + * if not isinstance(format, bytes): + */ + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_itemsize_0_for_cython_array); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + + /* "View.MemoryView":149 + * + * if not self._shape: + * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_shape_and_str); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "View.MemoryView":177 + * self.data = malloc(self.len) + * if not self.data: + * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< + * + * if self.dtype_is_object: + */ + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_array_data); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + + /* "View.MemoryView":193 + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") # <<<<<<<<<<<<<< + * info.buf = self.data + * info.len = self.len + */ + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_Can_only_create_a_buffer_that_is); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + + /* "(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__11 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + /* "(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__12 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "View.MemoryView":420 + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< + * + * have_slices, index = _unellipsify(index, self.view.ndim) + */ + __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_s_Cannot_assign_to_read_only_memor); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + + /* "View.MemoryView":497 + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< + * else: + * if len(self.view.format) == 1: + */ + __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_Unable_to_convert_item_to_object); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); + + /* "View.MemoryView":522 + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<< + * + * if flags & PyBUF_ND: + */ + __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_Cannot_create_writable_memory_vi); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(1, 522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__15); + __Pyx_GIVEREF(__pyx_tuple__15); + + /* "View.MemoryView":572 + * if self.view.strides == NULL: + * + * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) + */ + __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_Buffer_view_does_not_expose_stri); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(1, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); + + /* "View.MemoryView":579 + * def suboffsets(self): + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) + */ + __pyx_tuple__17 = PyTuple_New(1); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(1, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__17); + __Pyx_INCREF(__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_int_neg_1); + PyTuple_SET_ITEM(__pyx_tuple__17, 0, __pyx_int_neg_1); + __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":684 + * if item is Ellipsis: + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<< + * seen_ellipsis = True + * else: + */ + __pyx_slice__20 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__20)) __PYX_ERR(1, 684, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__20); + __Pyx_GIVEREF(__pyx_slice__20); + + /* "View.MemoryView":705 + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + * raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_Indirect_dimensions_not_supporte); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(1, 705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__21); + __Pyx_GIVEREF(__pyx_tuple__21); + + /* "(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__22 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__22); + __Pyx_GIVEREF(__pyx_tuple__22); + + /* "(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__23 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__23); + __Pyx_GIVEREF(__pyx_tuple__23); + __pyx_tuple__24 = PyTuple_Pack(3, __pyx_int_184977713, __pyx_int_136983863, __pyx_int_112105877); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__24); + __Pyx_GIVEREF(__pyx_tuple__24); + + /* "View.MemoryView":287 + * return self.name + * + * cdef generic = Enum("") # <<<<<<<<<<<<<< + * cdef strided = Enum("") # default + * cdef indirect = Enum("") + */ + __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(1, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__25); + __Pyx_GIVEREF(__pyx_tuple__25); + + /* "View.MemoryView":288 + * + * cdef generic = Enum("") + * cdef strided = Enum("") # default # <<<<<<<<<<<<<< + * cdef indirect = Enum("") + * + */ + __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(1, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__26); + __Pyx_GIVEREF(__pyx_tuple__26); + + /* "View.MemoryView":289 + * cdef generic = Enum("") + * cdef strided = Enum("") # default + * cdef indirect = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(1, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__27); + __Pyx_GIVEREF(__pyx_tuple__27); + + /* "View.MemoryView":292 + * + * + * cdef contiguous = Enum("") # <<<<<<<<<<<<<< + * cdef indirect_contiguous = Enum("") + * + */ + __pyx_tuple__28 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(1, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__28); + __Pyx_GIVEREF(__pyx_tuple__28); + + /* "View.MemoryView":293 + * + * cdef contiguous = Enum("") + * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__29 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(1, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__29); + __Pyx_GIVEREF(__pyx_tuple__29); + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + __pyx_tuple__30 = 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__30)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__30); + __Pyx_GIVEREF(__pyx_tuple__30); + __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__30, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __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) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_112105877 = PyInt_FromLong(112105877L); if (unlikely(!__pyx_int_112105877)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_136983863 = PyInt_FromLong(136983863L); if (unlikely(!__pyx_int_136983863)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_184977713 = PyInt_FromLong(184977713L); if (unlikely(!__pyx_int_184977713)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ + +static int __Pyx_modinit_global_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + generic = Py_None; Py_INCREF(Py_None); + strided = Py_None; Py_INCREF(Py_None); + indirect = Py_None; Py_INCREF(Py_None); + contiguous = Py_None; Py_INCREF(Py_None); + indirect_contiguous = Py_None; Py_INCREF(Py_None); + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + __pyx_vtabptr_array = &__pyx_vtable_array; + __pyx_vtable_array.get_memview = (PyObject *(*)(struct __pyx_array_obj *))__pyx_array_get_memview; + if (PyType_Ready(&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_array.tp_print = 0; + #endif + if (__Pyx_SetVtable(__pyx_type___pyx_array.tp_dict, __pyx_vtabptr_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) + __pyx_array_type = &__pyx_type___pyx_array; + if (PyType_Ready(&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 280, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_MemviewEnum.tp_print = 0; + #endif + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_MemviewEnum.tp_dictoffset && __pyx_type___pyx_MemviewEnum.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type___pyx_MemviewEnum.tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 280, __pyx_L1_error) + __pyx_MemviewEnum_type = &__pyx_type___pyx_MemviewEnum; + __pyx_vtabptr_memoryview = &__pyx_vtable_memoryview; + __pyx_vtable_memoryview.get_item_pointer = (char *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_get_item_pointer; + __pyx_vtable_memoryview.is_slice = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_is_slice; + __pyx_vtable_memoryview.setitem_slice_assignment = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_slice_assignment; + __pyx_vtable_memoryview.setitem_slice_assign_scalar = (PyObject *(*)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_setitem_slice_assign_scalar; + __pyx_vtable_memoryview.setitem_indexed = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_indexed; + __pyx_vtable_memoryview.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryview_convert_item_to_object; + __pyx_vtable_memoryview.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryview_assign_item_from_object; + if (PyType_Ready(&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_memoryview.tp_print = 0; + #endif + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryview.tp_dictoffset && __pyx_type___pyx_memoryview.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type___pyx_memoryview.tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + if (__Pyx_SetVtable(__pyx_type___pyx_memoryview.tp_dict, __pyx_vtabptr_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) + __pyx_memoryview_type = &__pyx_type___pyx_memoryview; + __pyx_vtabptr__memoryviewslice = &__pyx_vtable__memoryviewslice; + __pyx_vtable__memoryviewslice.__pyx_base = *__pyx_vtabptr_memoryview; + __pyx_vtable__memoryviewslice.__pyx_base.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryviewslice_convert_item_to_object; + __pyx_vtable__memoryviewslice.__pyx_base.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryviewslice_assign_item_from_object; + __pyx_type___pyx_memoryviewslice.tp_base = __pyx_memoryview_type; + if (PyType_Ready(&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_memoryviewslice.tp_print = 0; + #endif + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryviewslice.tp_dictoffset && __pyx_type___pyx_memoryviewslice.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type___pyx_memoryviewslice.tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + if (__Pyx_SetVtable(__pyx_type___pyx_memoryviewslice.tp_dict, __pyx_vtabptr__memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) + __pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyObject * +#endif +#endif + + +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initget_done_winner_cython(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initget_done_winner_cython(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_get_done_winner_cython(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_get_done_winner_cython(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_get_done_winner_cython(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 'get_done_winner_cython' 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_get_done_winner_cython(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + PyEval_InitThreads(); + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("get_done_winner_cython", __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_zoo__board_games__gomoku__envs__get_done_winner_cython) { + 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, "zoo.board_games.gomoku.envs.get_done_winner_cython")) { + if (unlikely(PyDict_SetItemString(modules, "zoo.board_games.gomoku.envs.get_done_winner_cython", __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 + + /* "zoo/board_games/gomoku/envs/get_done_winner_cython.pyx":1 + * from libc.stdint cimport int32_t # <<<<<<<<<<<<<< + * cimport cython + * + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":210 + * info.obj = self + * + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * def __dealloc__(array self): + */ + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_array_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_array_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 210, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_array_type); + + /* "View.MemoryView":287 + * return self.name + * + * cdef generic = Enum("") # <<<<<<<<<<<<<< + * cdef strided = Enum("") # default + * cdef indirect = Enum("") + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(generic); + __Pyx_DECREF_SET(generic, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":288 + * + * cdef generic = Enum("") + * cdef strided = Enum("") # default # <<<<<<<<<<<<<< + * cdef indirect = Enum("") + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(strided); + __Pyx_DECREF_SET(strided, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":289 + * cdef generic = Enum("") + * cdef strided = Enum("") # default + * cdef indirect = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(indirect); + __Pyx_DECREF_SET(indirect, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":292 + * + * + * cdef contiguous = Enum("") # <<<<<<<<<<<<<< + * cdef indirect_contiguous = Enum("") + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__28, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(contiguous); + __Pyx_DECREF_SET(contiguous, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":293 + * + * cdef contiguous = Enum("") + * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(indirect_contiguous); + __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":317 + * + * DEF THREAD_LOCKS_PREALLOCATED = 8 + * cdef int __pyx_memoryview_thread_locks_used = 0 # <<<<<<<<<<<<<< + * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ + * PyThread_allocate_lock(), + */ + __pyx_memoryview_thread_locks_used = 0; + + /* "View.MemoryView":318 + * DEF THREAD_LOCKS_PREALLOCATED = 8 + * cdef int __pyx_memoryview_thread_locks_used = 0 + * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ # <<<<<<<<<<<<<< + * PyThread_allocate_lock(), + * PyThread_allocate_lock(), + */ + __pyx_t_2[0] = PyThread_allocate_lock(); + __pyx_t_2[1] = PyThread_allocate_lock(); + __pyx_t_2[2] = PyThread_allocate_lock(); + __pyx_t_2[3] = PyThread_allocate_lock(); + __pyx_t_2[4] = PyThread_allocate_lock(); + __pyx_t_2[5] = PyThread_allocate_lock(); + __pyx_t_2[6] = PyThread_allocate_lock(); + __pyx_t_2[7] = PyThread_allocate_lock(); + memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_2, sizeof(__pyx_memoryview_thread_locks[0]) * (8)); + + /* "View.MemoryView":551 + * info.obj = self + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 551, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_memoryview_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 551, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_memoryview_type); + + /* "View.MemoryView":997 + * return self.from_object + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 997, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_memoryviewslice_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 997, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_memoryviewslice_type); + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum, NULL, __pyx_n_s_View_MemoryView); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Enum, __pyx_t_1) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init zoo.board_games.gomoku.envs.get_done_winner_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_CLEAR(__pyx_m); + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init zoo.board_games.gomoku.envs.get_done_winner_cython"); + } + __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; +} + +/* 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)); +} + +/* 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); +} + +/* MemviewSliceInit */ +static int +__Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview, + int ndim, + __Pyx_memviewslice *memviewslice, + int memview_is_new_reference) +{ + __Pyx_RefNannyDeclarations + int i, retval=-1; + Py_buffer *buf = &memview->view; + __Pyx_RefNannySetupContext("init_memviewslice", 0); + if (unlikely(memviewslice->memview || memviewslice->data)) { + PyErr_SetString(PyExc_ValueError, + "memviewslice is already initialized!"); + goto fail; + } + if (buf->strides) { + for (i = 0; i < ndim; i++) { + memviewslice->strides[i] = buf->strides[i]; + } + } else { + Py_ssize_t stride = buf->itemsize; + for (i = ndim - 1; i >= 0; i--) { + memviewslice->strides[i] = stride; + stride *= buf->shape[i]; + } + } + for (i = 0; i < ndim; i++) { + memviewslice->shape[i] = buf->shape[i]; + if (buf->suboffsets) { + memviewslice->suboffsets[i] = buf->suboffsets[i]; + } else { + memviewslice->suboffsets[i] = -1; + } + } + memviewslice->memview = memview; + memviewslice->data = (char *)buf->buf; + if (__pyx_add_acquisition_count(memview) == 0 && !memview_is_new_reference) { + Py_INCREF(memview); + } + retval = 0; + goto no_fail; +fail: + memviewslice->memview = 0; + memviewslice->data = 0; + retval = -1; +no_fail: + __Pyx_RefNannyFinishContext(); + return retval; +} +#ifndef Py_NO_RETURN +#define Py_NO_RETURN +#endif +static void __pyx_fatalerror(const char *fmt, ...) Py_NO_RETURN { + va_list vargs; + char msg[200]; +#if PY_VERSION_HEX >= 0x030A0000 || defined(HAVE_STDARG_PROTOTYPES) + va_start(vargs, fmt); +#else + va_start(vargs); +#endif + vsnprintf(msg, 200, fmt, vargs); + va_end(vargs); + Py_FatalError(msg); +} +static CYTHON_INLINE int +__pyx_add_acquisition_count_locked(__pyx_atomic_int *acquisition_count, + PyThread_type_lock lock) +{ + int result; + PyThread_acquire_lock(lock, 1); + result = (*acquisition_count)++; + PyThread_release_lock(lock); + return result; +} +static CYTHON_INLINE int +__pyx_sub_acquisition_count_locked(__pyx_atomic_int *acquisition_count, + PyThread_type_lock lock) +{ + int result; + PyThread_acquire_lock(lock, 1); + result = (*acquisition_count)--; + PyThread_release_lock(lock); + return result; +} +static CYTHON_INLINE void +__Pyx_INC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno) +{ + int first_time; + struct __pyx_memoryview_obj *memview = memslice->memview; + if (unlikely(!memview || (PyObject *) memview == Py_None)) + return; + if (unlikely(__pyx_get_slice_count(memview) < 0)) + __pyx_fatalerror("Acquisition count is %d (line %d)", + __pyx_get_slice_count(memview), lineno); + first_time = __pyx_add_acquisition_count(memview) == 0; + if (unlikely(first_time)) { + if (have_gil) { + Py_INCREF((PyObject *) memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_INCREF((PyObject *) memview); + PyGILState_Release(_gilstate); + } + } +} +static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *memslice, + int have_gil, int lineno) { + int last_time; + struct __pyx_memoryview_obj *memview = memslice->memview; + if (unlikely(!memview || (PyObject *) memview == Py_None)) { + memslice->memview = NULL; + return; + } + if (unlikely(__pyx_get_slice_count(memview) <= 0)) + __pyx_fatalerror("Acquisition count is %d (line %d)", + __pyx_get_slice_count(memview), lineno); + last_time = __pyx_sub_acquisition_count(memview) == 1; + memslice->data = NULL; + if (unlikely(last_time)) { + if (have_gil) { + Py_CLEAR(memslice->memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_CLEAR(memslice->memview); + PyGILState_Release(_gilstate); + } + } else { + memslice->memview = NULL; + } +} + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (exact) { + #if PY_MAJOR_VERSION == 2 + if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); + return 0; +} + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = Py_TYPE(func)->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* RaiseException */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_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 + +/* PyCFunctionFastCall */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + int flags = PyCFunction_GET_FLAGS(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { + return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); + } else { + return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + } +} +#endif + +/* PyFunctionFastCall */ +#if CYTHON_FAST_PYCALL +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif +#endif + +/* PyObjectCall2Args */ +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { + PyObject *args, *result = NULL; + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyFunction_FastCall(function, args, 2); + } + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyCFunction_FastCall(function, args, 2); + } + #endif + args = PyTuple_New(2); + if (unlikely(!args)) goto done; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + Py_INCREF(function); + result = __Pyx_PyObject_Call(function, args, NULL); + Py_DECREF(args); + Py_DECREF(function); +done: + return result; +} + +/* PyObjectCallMethO */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallOneArg */ +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif + if (likely(PyCFunction_Check(func))) { + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (__Pyx_PyFastCFunction_Check(func)) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else +#if PY_MAJOR_VERSION < 3 + PyObject* owned_ref = NULL; +#endif + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); +#if PY_MAJOR_VERSION < 3 + if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { + owned_ref = PyUnicode_FromObject(s2); + if (unlikely(!owned_ref)) + return -1; + s2 = owned_ref; + s2_is_unicode = 1; + } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { + owned_ref = PyUnicode_FromObject(s1); + if (unlikely(!owned_ref)) + return -1; + s1 = owned_ref; + s1_is_unicode = 1; + } else if (((!s2_is_unicode) & (!s1_is_unicode))) { + return __Pyx_PyBytes_Equals(s1, s2, equals); + } +#endif + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length; + int kind; + void *data1, *data2; + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + length = __Pyx_PyUnicode_GET_LENGTH(s1); + if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + #if CYTHON_PEP393_ENABLED + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + #else + hash1 = ((PyUnicodeObject*)s1)->hash; + hash2 = ((PyUnicodeObject*)s2)->hash; + #endif + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ); +return_ne: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_NE); +#endif +} + +/* DivInt[Py_ssize_t] */ +static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t a, Py_ssize_t b) { + Py_ssize_t q = a / b; + Py_ssize_t r = a - q*b; + q -= ((r != 0) & ((r ^ b) < 0)); + return q; +} + +/* GetAttr */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { +#if CYTHON_USE_TYPE_SLOTS +#if PY_MAJOR_VERSION >= 3 + if (likely(PyUnicode_Check(n))) +#else + if (likely(PyString_Check(n))) +#endif + return __Pyx_PyObject_GetAttrStr(o, n); +#endif + return PyObject_GetAttr(o, n); +} + +/* ObjectGetItem */ +#if CYTHON_USE_TYPE_SLOTS +static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { + PyObject *runerr = NULL; + Py_ssize_t key_value; + PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; + if (unlikely(!(m && m->sq_item))) { + PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); + return NULL; + } + key_value = __Pyx_PyIndex_AsSsize_t(index); + if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { + return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); + } + if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { + PyErr_Clear(); + PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); + } + return NULL; +} +static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { + PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; + if (likely(m && m->mp_subscript)) { + return m->mp_subscript(obj, key); + } + return __Pyx_PyObject_GetIndex(obj, key); +} +#endif + +/* decode_c_string */ +static CYTHON_INLINE PyObject* __Pyx_decode_c_string( + const char* cstring, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + Py_ssize_t length; + if (unlikely((start < 0) | (stop < 0))) { + size_t slen = strlen(cstring); + if (unlikely(slen > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, + "c-string too long to convert to Python"); + return NULL; + } + length = (Py_ssize_t) slen; + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + if (stop < 0) + stop += length; + } + if (unlikely(stop <= start)) + return __Pyx_NewRef(__pyx_empty_unicode); + length = stop - start; + cstring += start; + if (decode_func) { + return decode_func(cstring, length, errors); + } else { + return PyUnicode_Decode(cstring, length, encoding, errors); + } +} + +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; icurexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + if (unlikely(PyTuple_Check(err))) + return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); +} +#endif + +/* GetAttr3 */ +static PyObject *__Pyx_GetAttr3Default(PyObject *d) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + return NULL; + __Pyx_PyErr_Clear(); + Py_INCREF(d); + return d; +} +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { + PyObject *r = __Pyx_GetAttr(o, n); + return (likely(r)) ? r : __Pyx_GetAttr3Default(d); +} + +/* PyDictVersioning */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif + } + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); +} +#endif + +/* GetModuleGlobalName */ +#if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 + result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } else if (unlikely(PyErr_Occurred())) { + return NULL; + } +#else + result = PyDict_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } +#endif +#else + result = PyObject_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + +/* RaiseTooManyValuesToUnpack */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +/* RaiseNeedMoreValuesToUnpack */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +/* RaiseNoneIterError */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +/* ExtTypeTest */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +/* GetTopmostException */ +#if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; + } + return exc_info; +} +#endif + +/* SaveResetException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + #endif + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +#endif + +/* GetException */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) +#endif +{ + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + } + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +} + +/* SwapException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = *type; + exc_info->exc_value = *value; + exc_info->exc_traceback = *tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = *type; + tstate->exc_value = *value; + tstate->exc_traceback = *tb; + #endif + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); + PyErr_SetExcInfo(*type, *value, *tb); + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#endif + +/* Import */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_MAJOR_VERSION < 3 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +/* FastTypeChecks */ +#if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = a->tp_base; + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(a, b); +} +#if PY_MAJOR_VERSION == 2 +static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { + PyObject *exception, *value, *tb; + int res; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&exception, &value, &tb); + res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + if (!res) { + res = PyObject_IsSubclass(err, exc_type2); + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + } + __Pyx_ErrRestore(exception, value, tb); + return res; +} +#else +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; + if (!res) { + res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } + return res; +} +#endif +static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + assert(PyExceptionClass_Check(exc_type)); + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; i= 0 || (x^b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; +#ifdef HAVE_LONG_LONG + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; +#endif + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + default: return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + } + x = a + b; + return PyLong_FromLong(x); +#ifdef HAVE_LONG_LONG + long_long: + llx = lla + llb; + return PyLong_FromLongLong(llx); +#endif + + + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("add", return NULL) + result = ((double)a) + (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); +} +#endif + +/* DivInt[long] */ +static CYTHON_INLINE long __Pyx_div_long(long a, long b) { + long q = a / b; + long r = a - q*b; + q -= ((r != 0) & ((r ^ b) < 0)); + return q; +} + +/* ImportFrom */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +/* HasAttr */ +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { + PyObject *r; + if (unlikely(!__Pyx_PyBaseString_Check(n))) { + PyErr_SetString(PyExc_TypeError, + "hasattr(): attribute name must be string"); + return -1; + } + r = __Pyx_GetAttr(o, n); + if (unlikely(!r)) { + PyErr_Clear(); + return 0; + } else { + Py_DECREF(r); + return 1; + } +} + +/* PyObject_GenericGetAttrNoDict */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'%.50s' object has no attribute '%U'", + tp->tp_name, attr_name); +#else + "'%.50s' object has no attribute '%.400s'", + tp->tp_name, PyString_AS_STRING(attr_name)); +#endif + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { + PyObject *descr; + PyTypeObject *tp = Py_TYPE(obj); + if (unlikely(!PyString_Check(attr_name))) { + return PyObject_GenericGetAttr(obj, attr_name); + } + assert(!tp->tp_dictoffset); + descr = _PyType_Lookup(tp, attr_name); + if (unlikely(!descr)) { + return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); + } + Py_INCREF(descr); + #if PY_MAJOR_VERSION < 3 + if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) + #endif + { + descrgetfunc f = Py_TYPE(descr)->tp_descr_get; + if (unlikely(f)) { + PyObject *res = f(descr, obj, (PyObject *)tp); + Py_DECREF(descr); + return res; + } + } + return descr; +} +#endif + +/* PyObject_GenericGetAttr */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { + if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { + return PyObject_GenericGetAttr(obj, attr_name); + } + return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); +} +#endif + +/* SetVTable */ +static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); +#else + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#endif + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +/* PyObjectGetAttrStrNoError */ +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +} + +/* SetupReduce */ +static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2); + if (likely(name_attr)) { + ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); + } else { + ret = -1; + } + if (unlikely(ret < 0)) { + PyErr_Clear(); + ret = 0; + } + Py_XDECREF(name_attr); + return ret; +} +static int __Pyx_setup_reduce(PyObject* type_obj) { + int ret = 0; + PyObject *object_reduce = NULL; + PyObject *object_getstate = NULL; + PyObject *object_reduce_ex = NULL; + PyObject *reduce = NULL; + PyObject *reduce_ex = NULL; + PyObject *reduce_cython = NULL; + PyObject *setstate = NULL; + PyObject *setstate_cython = NULL; + PyObject *getstate = NULL; +#if CYTHON_USE_PYTYPE_LOOKUP + getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); +#else + getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); + if (!getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (getstate) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); +#else + object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); + if (!object_getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (object_getstate != getstate) { + goto __PYX_GOOD; + } + } +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#else + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#endif + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; + if (reduce_ex == object_reduce_ex) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#else + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#endif + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; + if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { + reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); + if (likely(reduce_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (reduce == object_reduce || PyErr_Occurred()) { + goto __PYX_BAD; + } + setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); + if (!setstate) PyErr_Clear(); + if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { + setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); + if (likely(setstate_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (!setstate || PyErr_Occurred()) { + goto __PYX_BAD; + } + } + PyType_Modified((PyTypeObject*)type_obj); + } + } + goto __PYX_GOOD; +__PYX_BAD: + if (!PyErr_Occurred()) + PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); + ret = -1; +__PYX_GOOD: +#if !CYTHON_USE_PYTYPE_LOOKUP + Py_XDECREF(object_reduce); + Py_XDECREF(object_reduce_ex); + Py_XDECREF(object_getstate); + Py_XDECREF(getstate); +#endif + Py_XDECREF(reduce); + Py_XDECREF(reduce_ex); + Py_XDECREF(reduce_cython); + Py_XDECREF(setstate); + Py_XDECREF(setstate_cython); + return ret; +} + +/* CLineInTraceback */ +#ifndef CYTHON_CLINE_IN_TRACEBACK +static int __Pyx_CLineForTraceback(CYTHON_UNUSED PyThreadState *tstate, int c_line) { + PyObject *use_cline; + PyObject *ptype, *pvalue, *ptraceback; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict; +#endif + if (unlikely(!__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, *cython_runtime_dict, + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) + } else +#endif + { + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } + } + if (!use_cline) { + c_line = 0; + (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + } + else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache */ +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = NULL; + PyObject *py_funcname = NULL; + #if PY_MAJOR_VERSION < 3 + PyObject *py_srcfile = NULL; + py_srcfile = PyString_FromString(filename); + if (!py_srcfile) goto bad; + #endif + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + funcname = PyUnicode_AsUTF8(py_funcname); + if (!funcname) goto bad; + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + if (!py_funcname) goto bad; + #endif + } + #if PY_MAJOR_VERSION < 3 + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + #else + py_code = PyCode_NewEmpty(filename, funcname, py_line); + #endif + Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline + return py_code; +bad: + Py_XDECREF(py_funcname); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_srcfile); + #endif + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject *ptype, *pvalue, *ptraceback; + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); + } + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) { + /* If the code object creation fails, then we should clear the + fetched exception references and propagate the new exception */ + Py_XDECREF(ptype); + Py_XDECREF(pvalue); + Py_XDECREF(ptraceback); + goto bad; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#if PY_MAJOR_VERSION < 3 +static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { + if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); + if (__Pyx_TypeCheck(obj, __pyx_array_type)) return __pyx_array_getbuffer(obj, view, flags); + if (__Pyx_TypeCheck(obj, __pyx_memoryview_type)) return __pyx_memoryview_getbuffer(obj, view, flags); + PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); + return -1; +} +static void __Pyx_ReleaseBuffer(Py_buffer *view) { + PyObject *obj = view->obj; + if (!obj) return; + if (PyObject_CheckBuffer(obj)) { + PyBuffer_Release(view); + return; + } + if ((0)) {} + view->obj = NULL; + Py_DECREF(obj); +} +#endif + + +/* MemviewSliceIsContig */ +static int +__pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim) +{ + int i, index, step, start; + Py_ssize_t itemsize = mvs.memview->view.itemsize; + if (order == 'F') { + step = 1; + start = 0; + } else { + step = -1; + start = ndim - 1; + } + for (i = 0; i < ndim; i++) { + index = start + step * i; + if (mvs.suboffsets[index] >= 0 || mvs.strides[index] != itemsize) + return 0; + itemsize *= mvs.shape[index]; + } + return 1; +} + +/* OverlappingSlices */ +static void +__pyx_get_array_memory_extents(__Pyx_memviewslice *slice, + void **out_start, void **out_end, + int ndim, size_t itemsize) +{ + char *start, *end; + int i; + start = end = slice->data; + for (i = 0; i < ndim; i++) { + Py_ssize_t stride = slice->strides[i]; + Py_ssize_t extent = slice->shape[i]; + if (extent == 0) { + *out_start = *out_end = start; + return; + } else { + if (stride > 0) + end += stride * (extent - 1); + else + start += stride * (extent - 1); + } + } + *out_start = start; + *out_end = end + itemsize; +} +static int +__pyx_slices_overlap(__Pyx_memviewslice *slice1, + __Pyx_memviewslice *slice2, + int ndim, size_t itemsize) +{ + void *start1, *end1, *start2, *end2; + __pyx_get_array_memory_extents(slice1, &start1, &end1, ndim, itemsize); + __pyx_get_array_memory_extents(slice2, &start2, &end2, ndim, itemsize); + return (start1 < end2) && (start2 < end1); +} + +/* Capsule */ +static CYTHON_INLINE PyObject * +__pyx_capsule_create(void *p, CYTHON_UNUSED const char *sig) +{ + PyObject *cobj; +#if PY_VERSION_HEX >= 0x02070000 + cobj = PyCapsule_New(p, sig, NULL); +#else + cobj = PyCObject_FromVoidPtr(p, NULL); +#endif + return cobj; +} + +/* 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;\ + } + +/* 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_dsds_nn_int32_t(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_STRIDED), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_STRIDED) }; + int retcode; + if (obj == Py_None) { + result.memview = (struct __pyx_memoryview_obj *) Py_None; + return result; + } + retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, 0, + PyBUF_RECORDS_RO | writable_flag, 2, + &__Pyx_TypeInfo_nn_int32_t, stack, + &result, obj); + if (unlikely(retcode == -1)) + goto __pyx_fail; + return result; +__pyx_fail: + result.memview = NULL; + result.data = NULL; + return result; +} + +/* 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 int32_t __Pyx_PyInt_As_int32_t(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int32_t neg_one = (int32_t) -1, const_zero = (int32_t) 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(int32_t) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int32_t, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int32_t) 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 (int32_t) 0; + case 1: __PYX_VERIFY_RETURN_INT(int32_t, digit, digits[0]) + case 2: + if (8 * sizeof(int32_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) >= 2 * PyLong_SHIFT) { + return (int32_t) (((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int32_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) >= 3 * PyLong_SHIFT) { + return (int32_t) (((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int32_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, 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(int32_t) >= 4 * PyLong_SHIFT) { + return (int32_t) (((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)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 (int32_t) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int32_t) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int32_t, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int32_t) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int32_t, 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 (int32_t) 0; + case -1: __PYX_VERIFY_RETURN_INT(int32_t, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int32_t, digit, +digits[0]) + case -2: + if (8 * sizeof(int32_t) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT) { + return (int32_t) (((int32_t)-1)*(((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int32_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT) { + return (int32_t) ((((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT) { + return (int32_t) (((int32_t)-1)*(((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int32_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT) { + return (int32_t) ((((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, 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(int32_t) - 1 > 4 * PyLong_SHIFT) { + return (int32_t) (((int32_t)-1)*(((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int32_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, 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(int32_t) - 1 > 4 * PyLong_SHIFT) { + return (int32_t) ((((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int32_t) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int32_t, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int32_t) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int32_t, 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 + int32_t 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 (int32_t) -1; + } + } else { + int32_t val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int32_t) -1; + val = __Pyx_PyInt_As_int32_t(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int32_t"); + return (int32_t) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int32_t"); + return (int32_t) -1; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int32_t(int32_t value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int32_t neg_one = (int32_t) -1, const_zero = (int32_t) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int32_t) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int32_t) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int32_t) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int32_t) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int32_t) <= 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(int32_t), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const char neg_one = (char) -1, const_zero = (char) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(char) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(char, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (char) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (char) 0; + case 1: __PYX_VERIFY_RETURN_INT(char, digit, digits[0]) + case 2: + if (8 * sizeof(char) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 2 * PyLong_SHIFT) { + return (char) (((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(char) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 3 * PyLong_SHIFT) { + return (char) (((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(char) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 4 * PyLong_SHIFT) { + return (char) (((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (char) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(char) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(char, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(char) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (char) 0; + case -1: __PYX_VERIFY_RETURN_INT(char, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(char, digit, +digits[0]) + case -2: + if (8 * sizeof(char) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(char) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + return (char) ((((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(char) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + return (char) ((((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(char) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) { + return (char) ((((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + } +#endif + if (sizeof(char) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(char, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(char) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(char, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + char val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (char) -1; + } + } else { + char val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (char) -1; + val = __Pyx_PyInt_As_char(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to char"); + return (char) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to char"); + return (char) -1; +} + +/* CheckBinaryVersion */ + static int __Pyx_check_binary_version(void) { + char ctversion[5]; + int same=1, i, found_dot; + const char* rt_from_call = Py_GetVersion(); + PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + found_dot = 0; + for (i = 0; i < 4; i++) { + if (!ctversion[i]) { + same = (rt_from_call[i] < '0' || rt_from_call[i] > '9'); + break; + } + if (rt_from_call[i] != ctversion[i]) { + same = 0; + break; + } + } + if (!same) { + char rtversion[5] = {'\0'}; + char message[200]; + for (i=0; i<4; ++i) { + if (rt_from_call[i] == '.') { + if (found_dot) break; + found_dot = 1; + } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { + break; + } + rtversion[i] = rt_from_call[i]; + } + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +/* InitStrings */ + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + if (PyObject_Hash(*t->p) == -1) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#if !CYTHON_PEP393_ENABLED +static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +} +#else +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (likely(PyUnicode_IS_ASCII(o))) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +} +#endif +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { + int retval; + if (unlikely(!x)) return -1; + retval = __Pyx_PyObject_IsTrue(x); + Py_DECREF(x); + return retval; +} +static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { +#if PY_MAJOR_VERSION >= 3 + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type %.200s). " + "The ability to return an instance of a strict subclass of int " + "is deprecated, and may be removed in a future version of Python.", + Py_TYPE(result)->tp_name)) { + Py_DECREF(result); + return NULL; + } + return result; + } +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + type_name, type_name, Py_TYPE(result)->tp_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x) || PyLong_Check(x))) +#else + if (likely(PyLong_Check(x))) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = m->nb_int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = m->nb_long(x); + } + #else + if (likely(m && m->nb_int)) { + name = "int"; + res = m->nb_int(x); + } + #endif +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Int(x); + } +#endif + if (likely(res)) { +#if PY_MAJOR_VERSION < 3 + if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { +#else + if (unlikely(!PyLong_CheckExact(res))) { +#endif + return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(b); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { + if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { + return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); +#if PY_MAJOR_VERSION < 3 + } else if (likely(PyInt_CheckExact(o))) { + return PyInt_AS_LONG(o); +#endif + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyInt_AsLong(x); + Py_DECREF(x); + return ival; + } +} +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/zoo/board_games/gomoku/envs/legal_actions_cython.cpp b/zoo/board_games/gomoku/envs/legal_actions_cython.cpp new file mode 100644 index 000000000..d206c5d8d --- /dev/null +++ b/zoo/board_games/gomoku/envs/legal_actions_cython.cpp @@ -0,0 +1,21203 @@ +/* Generated by Cython 0.29.34 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [], + "include_dirs": [ + "/private/var/folders/r5/znmp_3cn0_b41yvr2tvld9ys0qypks/T/pip-build-env-6l8r0sjs/overlay/lib/python3.8/site-packages/numpy/core/include" + ], + "language": "c++", + "name": "zoo.board_games.gomoku.envs.legal_actions_cython", + "sources": [ + "/Users/puyuan/code/LightZero/zoo/board_games/gomoku/envs/legal_actions_cython.pyx" + ] + }, + "module_name": "zoo.board_games.gomoku.envs.legal_actions_cython" +} +END: Cython Metadata */ + +#ifndef PY_SSIZE_T_CLEAN +#define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.6+ or Python 3.3+. +#else +#define CYTHON_ABI "0_29_34" +#define CYTHON_HEX_VERSION 0x001D22F0 +#define CYTHON_FUTURE_DIVISION 1 +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#define __PYX_COMMA , +#ifndef HAVE_LONG_LONG + #if PY_VERSION_HEX >= 0x02070000 + #define HAVE_LONG_LONG + #endif +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif +#elif defined(PY_NOGIL) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_NOGIL 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #ifndef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_NOGIL 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #define CYTHON_USE_PYLONG_INTERNALS (PY_VERSION_HEX < 0x030C00A5) + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #if PY_VERSION_HEX >= 0x030B00A4 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #elif !defined(CYTHON_FAST_THREAD_STATE) + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #endif + #ifndef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS ((PY_VERSION_HEX >= 0x030600B1) && (PY_VERSION_HEX < 0x030C00A5)) + #endif + #if PY_VERSION_HEX >= 0x030B00A4 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #elif !defined(CYTHON_USE_EXC_INFO_STACK) + #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #endif + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_MAJOR_VERSION < 3 + #include "longintrepr.h" + #endif + #undef SHIFT + #undef BASE + #undef MASK + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + #endif +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) +#ifdef _MSC_VER + #ifndef _MSC_STDINT_H_ + #if _MSC_VER < 1300 + typedef unsigned char uint8_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int32 uint32_t; + #endif + #endif +#else + #include +#endif +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) && __cplusplus >= 201103L + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #elif __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + #if defined(__clang__ ) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif + +#ifndef __cplusplus + #error "Cython files generated with the C++ option must be compiled with a C++ compiler." +#endif +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #else + #define CYTHON_INLINE inline + #endif +#endif +template +void __Pyx_call_destructor(T& x) { + x.~T(); +} +template +class __Pyx_FakeReference { + public: + __Pyx_FakeReference() : ptr(NULL) { } + __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { } + T *operator->() { return ptr; } + T *operator&() { return ptr; } + operator T&() { return *ptr; } + template bool operator ==(U other) { return *ptr == other; } + template bool operator !=(U other) { return *ptr != other; } + private: + T *ptr; +}; + +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_DefaultClassType PyType_Type +#if PY_VERSION_HEX >= 0x030B00A1 + static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; + PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; + const char *fn_cstr=NULL; + const char *name_cstr=NULL; + PyCodeObject* co=NULL; + PyObject *type, *value, *traceback; + PyErr_Fetch(&type, &value, &traceback); + if (!(kwds=PyDict_New())) goto end; + if (!(argcount=PyLong_FromLong(a))) goto end; + if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; + if (!(posonlyargcount=PyLong_FromLong(0))) goto end; + if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; + if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; + if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; + if (!(nlocals=PyLong_FromLong(l))) goto end; + if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; + if (!(stacksize=PyLong_FromLong(s))) goto end; + if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; + if (!(flags=PyLong_FromLong(f))) goto end; + if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; + if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; + if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; + if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; + if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; + if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here + if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; + Py_XDECREF((PyObject*)co); + co = (PyCodeObject*)call_result; + call_result = NULL; + if (0) { + cleanup_code_too: + Py_XDECREF((PyObject*)co); + co = NULL; + } + end: + Py_XDECREF(kwds); + Py_XDECREF(argcount); + Py_XDECREF(posonlyargcount); + Py_XDECREF(kwonlyargcount); + Py_XDECREF(nlocals); + Py_XDECREF(stacksize); + Py_XDECREF(replace); + Py_XDECREF(call_result); + Py_XDECREF(empty); + if (type) { + PyErr_Restore(type, value, traceback); + } + return co; + } +#else + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#endif + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef METH_STACKLESS + #define METH_STACKLESS 0 +#endif +#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) + #ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #define __Pyx_PyCFunctionFast _PyCFunctionFast + #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords +#endif +#if CYTHON_FAST_PYCCALL +#define __Pyx_PyFastCFunction_Check(func)\ + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +#else +#define __Pyx_PyFastCFunction_Check(func) 0 +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 + #define PyMem_RawMalloc(n) PyMem_Malloc(n) + #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) + #define PyMem_RawFree(p) PyMem_Free(p) +#endif +#if CYTHON_COMPILING_IN_PYSTON + #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x03060000 + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#elif PY_VERSION_HEX >= 0x03000000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_Current +#endif +#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) +#include "pythread.h" +#define Py_tss_NEEDS_INIT 0 +typedef int Py_tss_t; +static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { + *key = PyThread_create_key(); + return 0; +} +static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { + Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); + *key = Py_tss_NEEDS_INIT; + return key; +} +static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { + PyObject_Free(key); +} +static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { + return *key != Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { + PyThread_delete_key(*key); + *key = Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { + return PyThread_set_key_value(*key, value); +} +static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { + return PyThread_get_key_value(*key); +} +#endif +#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif +#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#else +#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #if 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_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 PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #else + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif + #endif +#else + #define CYTHON_PEP393_ENABLED 0 + #define PyUnicode_1BYTE_KIND 1 + #define PyUnicode_2BYTE_KIND 2 + #define PyUnicode_4BYTE_KIND 4 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#ifndef PyObject_Unicode + #define PyObject_Unicode PyObject_Str +#endif +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) +#else + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef __Pyx_PyAsyncMethodsStruct + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; +#endif + +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #if !defined(_USE_MATH_DEFINES) + #define _USE_MATH_DEFINES + #endif +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + +#define __PYX_MARK_ERR_POS(f_index, lineno) \ + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__zoo__board_games__gomoku__envs__legal_actions_cython +#define __PYX_HAVE_API__zoo__board_games__gomoku__envs__legal_actions_cython +/* Early includes */ +#include +#include "pythread.h" +#include +#include +#include +#include "pystate.h" +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { + return (size_t) i < (size_t) limit; +} +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) + #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +#define __Pyx_PySequence_Tuple(obj)\ + (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); +#if CYTHON_ASSUME_SAFE_MACROS +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } + +static PyObject *__pyx_m = NULL; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_cython_runtime = NULL; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + + +static const char *__pyx_f[] = { + "zoo/board_games/gomoku/envs/legal_actions_cython.pyx", + "stringsource", +}; +/* MemviewSliceStruct.proto */ +struct __pyx_memoryview_obj; +typedef struct { + struct __pyx_memoryview_obj *memview; + char *data; + Py_ssize_t shape[8]; + Py_ssize_t strides[8]; + Py_ssize_t suboffsets[8]; +} __Pyx_memviewslice; +#define __Pyx_MemoryView_Len(m) (m.shape[0]) + +/* Atomics.proto */ +#include +#ifndef CYTHON_ATOMICS + #define CYTHON_ATOMICS 1 +#endif +#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS +#define __pyx_atomic_int_type int +#if CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\ + (__GNUC_MINOR__ > 1 ||\ + (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) + #define __pyx_atomic_incr_aligned(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_decr_aligned(value) __sync_fetch_and_sub(value, 1) + #ifdef __PYX_DEBUG_ATOMICS + #warning "Using GNU atomics" + #endif +#elif CYTHON_ATOMICS && defined(_MSC_VER) && CYTHON_COMPILING_IN_NOGIL + #include + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type long + #pragma intrinsic (_InterlockedExchangeAdd) + #define __pyx_atomic_incr_aligned(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_decr_aligned(value) _InterlockedExchangeAdd(value, -1) + #ifdef __PYX_DEBUG_ATOMICS + #pragma message ("Using MSVC atomics") + #endif +#else + #undef CYTHON_ATOMICS + #define CYTHON_ATOMICS 0 + #ifdef __PYX_DEBUG_ATOMICS + #warning "Not using atomics" + #endif +#endif +typedef volatile __pyx_atomic_int_type __pyx_atomic_int; +#if CYTHON_ATOMICS + #define __pyx_add_acquisition_count(memview)\ + __pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview)) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview)) +#else + #define __pyx_add_acquisition_count(memview)\ + __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) +#endif + +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + +/* NoFastGil.proto */ +#define __Pyx_PyGILState_Ensure PyGILState_Ensure +#define __Pyx_PyGILState_Release PyGILState_Release +#define __Pyx_FastGIL_Remember() +#define __Pyx_FastGIL_Forget() +#define __Pyx_FastGilFuncInit() + +/* BufferFormatStructs.proto */ +#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; + +/* "View.MemoryView":106 + * + * @cname("__pyx_array") + * cdef class array: # <<<<<<<<<<<<<< + * + * cdef: + */ +struct __pyx_array_obj { + PyObject_HEAD + struct __pyx_vtabstruct_array *__pyx_vtab; + char *data; + Py_ssize_t len; + char *format; + int ndim; + Py_ssize_t *_shape; + Py_ssize_t *_strides; + Py_ssize_t itemsize; + PyObject *mode; + PyObject *_format; + void (*callback_free_data)(void *); + int free_data; + int dtype_is_object; +}; + + +/* "View.MemoryView":280 + * + * @cname('__pyx_MemviewEnum') + * cdef class Enum(object): # <<<<<<<<<<<<<< + * cdef object name + * def __init__(self, name): + */ +struct __pyx_MemviewEnum_obj { + PyObject_HEAD + PyObject *name; +}; + + +/* "View.MemoryView":331 + * + * @cname('__pyx_memoryview') + * cdef class memoryview(object): # <<<<<<<<<<<<<< + * + * cdef object obj + */ +struct __pyx_memoryview_obj { + PyObject_HEAD + struct __pyx_vtabstruct_memoryview *__pyx_vtab; + PyObject *obj; + PyObject *_size; + PyObject *_array_interface; + PyThread_type_lock lock; + __pyx_atomic_int acquisition_count[2]; + __pyx_atomic_int *acquisition_count_aligned_p; + Py_buffer view; + int flags; + int dtype_is_object; + __Pyx_TypeInfo *typeinfo; +}; + + +/* "View.MemoryView":967 + * + * @cname('__pyx_memoryviewslice') + * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< + * "Internal class for passing memoryview slices to Python" + * + */ +struct __pyx_memoryviewslice_obj { + struct __pyx_memoryview_obj __pyx_base; + __Pyx_memviewslice from_slice; + PyObject *from_object; + PyObject *(*to_object_func)(char *); + int (*to_dtype_func)(char *, PyObject *); +}; + + + +/* "View.MemoryView":106 + * + * @cname("__pyx_array") + * cdef class array: # <<<<<<<<<<<<<< + * + * cdef: + */ + +struct __pyx_vtabstruct_array { + PyObject *(*get_memview)(struct __pyx_array_obj *); +}; +static struct __pyx_vtabstruct_array *__pyx_vtabptr_array; + + +/* "View.MemoryView":331 + * + * @cname('__pyx_memoryview') + * cdef class memoryview(object): # <<<<<<<<<<<<<< + * + * cdef object obj + */ + +struct __pyx_vtabstruct_memoryview { + char *(*get_item_pointer)(struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*is_slice)(struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*setitem_slice_assignment)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); + PyObject *(*setitem_slice_assign_scalar)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*setitem_indexed)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); + PyObject *(*convert_item_to_object)(struct __pyx_memoryview_obj *, char *); + PyObject *(*assign_item_from_object)(struct __pyx_memoryview_obj *, char *, PyObject *); +}; +static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview; + + +/* "View.MemoryView":967 + * + * @cname('__pyx_memoryviewslice') + * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< + * "Internal class for passing memoryview slices to Python" + * + */ + +struct __pyx_vtabstruct__memoryviewslice { + struct __pyx_vtabstruct_memoryview __pyx_base; +}; +static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice; + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* 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); + +/* 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 + +/* 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); + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* PyCFunctionFastCall.proto */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#else +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); +#else +#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) +#endif +#define __Pyx_BUILD_ASSERT_EXPR(cond)\ + (sizeof(char [1 - 2*!(cond)]) - 1) +#ifndef Py_MEMBER_SIZE +#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) +#endif +#if CYTHON_FAST_PYCALL + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" +#if PY_VERSION_HEX >= 0x030b00a6 + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif + #define __Pxy_PyFrame_Initialize_Offsets()\ + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) + #define __Pyx_PyFrame_GetLocalsplus(frame)\ + (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#endif // CYTHON_FAST_PYCALL +#endif + +/* PyObjectCall2Args.proto */ +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* StrEquals.proto */ +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals +#else +#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals +#endif + +/* DivInt[Py_ssize_t].proto */ +static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t, Py_ssize_t); + +/* UnaryNegOverflows.proto */ +#define UNARY_NEG_WOULD_OVERFLOW(x)\ + (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x))) + +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *); /*proto*/ +/* GetAttr.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +/* ObjectGetItem.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); +#else +#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) +#endif + +/* decode_c_string_utf16.proto */ +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = 0; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = -1; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = 1; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} + +/* decode_c_string.proto */ +static CYTHON_INLINE PyObject* __Pyx_decode_c_string( + const char* cstring, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); + +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* GetAttr3.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); + +/* PyDictVersioning.proto */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) +#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ + (version_var) = __PYX_GET_DICT_VERSION(dict);\ + (cache_var) = (value); +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ + (VAR) = __pyx_dict_cached_value;\ + } else {\ + (VAR) = __pyx_dict_cached_value = (LOOKUP);\ + __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ + }\ +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); +#else +#define __PYX_GET_DICT_VERSION(dict) (0) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); +#endif + +/* GetModuleGlobalName.proto */ +#if CYTHON_USE_DICT_VERSIONS +#define __Pyx_GetModuleGlobalName(var, name) do {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ + (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ + __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ + PY_UINT64_T __pyx_dict_version;\ + PyObject *__pyx_dict_cached_value;\ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); +#else +#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) +#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); +#endif + +/* 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 +} + +/* None.proto */ +static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); + +/* DivInt[long].proto */ +static CYTHON_INLINE long __Pyx_div_long(long, long); + +/* PySequenceContains.proto */ +static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { + int result = PySequence_Contains(seq, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +/* ImportFrom.proto */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +/* HasAttr.proto */ +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); + +/* 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); + +/* GCCDiagnostics.proto */ +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + +/* 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_dsds_nn_int32_t(PyObject *, int writable_flag); + +/* MemviewSliceCopyTemplate.proto */ +static __Pyx_memviewslice +__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, + const char *mode, int ndim, + size_t sizeof_dtype, int contig_flag, + int dtype_is_object); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* 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 'libc.stdint' */ + +/* Module declarations from 'cython.view' */ + +/* Module declarations from 'cython' */ + +/* Module declarations from 'zoo.board_games.gomoku.envs.legal_actions_cython' */ +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 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_nn_int32_t = { "int32_t", NULL, sizeof(int32_t), { 0 }, 0, IS_UNSIGNED(int32_t) ? 'U' : 'I', IS_UNSIGNED(int32_t), 0 }; +#define __Pyx_MODULE_NAME "zoo.board_games.gomoku.envs.legal_actions_cython" +extern int __pyx_module_is_main_zoo__board_games__gomoku__envs__legal_actions_cython; +int __pyx_module_is_main_zoo__board_games__gomoku__envs__legal_actions_cython = 0; + +/* Implementation of 'zoo.board_games.gomoku.envs.legal_actions_cython' */ +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_i[] = "i"; +static const char __pyx_k_j[] = "j"; +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_test[] = "__test__"; +static const char __pyx_k_ASCII[] = "ASCII"; +static const char __pyx_k_board[] = "board"; +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_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_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_board_size[] = "board_size"; +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_legal_actions[] = "legal_actions"; +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_legal_actions_cython[] = "legal_actions_cython"; +static const char __pyx_k_strided_and_indirect[] = ""; +static const char __pyx_k_contiguous_and_direct[] = ""; +static const char __pyx_k_MemoryView_of_r_object[] = ""; +static const char __pyx_k_MemoryView_of_r_at_0x_x[] = ""; +static const char __pyx_k_contiguous_and_indirect[] = ""; +static const char __pyx_k_Cannot_index_with_type_s[] = "Cannot index with type '%s'"; +static const char __pyx_k_Invalid_shape_in_axis_d_d[] = "Invalid shape in axis %d: %d."; +static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array"; +static const char __pyx_k_unable_to_allocate_array_data[] = "unable to allocate array data."; +static const char __pyx_k_strided_and_direct_or_indirect[] = ""; +static const char __pyx_k_Buffer_view_does_not_expose_stri[] = "Buffer view does not expose strides"; +static const char __pyx_k_Can_only_create_a_buffer_that_is[] = "Can only create a buffer that is contiguous in memory."; +static const char __pyx_k_Cannot_assign_to_read_only_memor[] = "Cannot assign to read-only memoryview"; +static const char __pyx_k_Cannot_create_writable_memory_vi[] = "Cannot create writable memory view from read-only memoryview"; +static const char __pyx_k_Empty_shape_tuple_for_cython_arr[] = "Empty shape tuple for cython.array"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))"; +static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported"; +static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got %s"; +static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis %d)"; +static const char __pyx_k_Unable_to_convert_item_to_object[] = "Unable to convert item to object"; +static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension %d (got %d and %d)"; +static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; +static const char __pyx_k_unable_to_allocate_shape_and_str[] = "unable to allocate shape and strides."; +static const char __pyx_k_zoo_board_games_gomoku_envs_lega[] = "zoo/board_games/gomoku/envs/legal_actions_cython.pyx"; +static const char __pyx_k_zoo_board_games_gomoku_envs_lega_2[] = "zoo.board_games.gomoku.envs.legal_actions_cython"; +static PyObject *__pyx_n_s_ASCII; +static PyObject *__pyx_kp_s_Buffer_view_does_not_expose_stri; +static PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is; +static PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor; +static PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi; +static PyObject *__pyx_kp_s_Cannot_index_with_type_s; +static PyObject *__pyx_n_s_Ellipsis; +static PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr; +static PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; +static PyObject *__pyx_n_s_IndexError; +static PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte; +static PyObject *__pyx_kp_s_Invalid_mode_expected_c_or_fortr; +static PyObject *__pyx_kp_s_Invalid_shape_in_axis_d_d; +static PyObject *__pyx_n_s_MemoryError; +static PyObject *__pyx_kp_s_MemoryView_of_r_at_0x_x; +static PyObject *__pyx_kp_s_MemoryView_of_r_object; +static PyObject *__pyx_n_b_O; +static PyObject *__pyx_kp_s_Out_of_bounds_on_buffer_access_a; +static PyObject *__pyx_n_s_PickleError; +static PyObject *__pyx_n_s_TypeError; +static PyObject *__pyx_kp_s_Unable_to_convert_item_to_object; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_View_MemoryView; +static PyObject *__pyx_n_s_allocate_buffer; +static PyObject *__pyx_n_s_base; +static PyObject *__pyx_n_s_board; +static PyObject *__pyx_n_s_board_size; +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_i; +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_j; +static PyObject *__pyx_n_s_legal_actions; +static PyObject *__pyx_n_s_legal_actions_cython; +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_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_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_kp_s_zoo_board_games_gomoku_envs_lega; +static PyObject *__pyx_n_s_zoo_board_games_gomoku_envs_lega_2; +static PyObject *__pyx_pf_3zoo_11board_games_6gomoku_4envs_20legal_actions_cython_legal_actions_cython(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_board_size, __Pyx_memviewslice __pyx_v_board); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr); /* proto */ +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ +static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object); /* proto */ +static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_1; +static PyObject *__pyx_int_112105877; +static PyObject *__pyx_int_136983863; +static PyObject *__pyx_int_184977713; +static PyObject *__pyx_int_neg_1; +static PyObject *__pyx_tuple_; +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__15; +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__16; +static PyObject *__pyx_tuple__17; +static PyObject *__pyx_tuple__18; +static PyObject *__pyx_tuple__19; +static PyObject *__pyx_tuple__20; +static PyObject *__pyx_tuple__22; +static PyObject *__pyx_tuple__23; +static PyObject *__pyx_tuple__24; +static PyObject *__pyx_tuple__25; +static PyObject *__pyx_tuple__26; +static PyObject *__pyx_tuple__27; +static PyObject *__pyx_codeobj__21; +static PyObject *__pyx_codeobj__28; +/* Late includes */ + +/* "zoo/board_games/gomoku/envs/legal_actions_cython.pyx":6 + * @cython.boundscheck(False) # Disable bounds checking for performance + * @cython.wraparound(False) # Disable negative indexing for performance + * def legal_actions_cython(int board_size, int32_t[:, :] board): # <<<<<<<<<<<<<< + * # Use a Python list to store possible legal actions + * cdef list legal_actions = [] + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_3zoo_11board_games_6gomoku_4envs_20legal_actions_cython_1legal_actions_cython(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_3zoo_11board_games_6gomoku_4envs_20legal_actions_cython_1legal_actions_cython = {"legal_actions_cython", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_3zoo_11board_games_6gomoku_4envs_20legal_actions_cython_1legal_actions_cython, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_3zoo_11board_games_6gomoku_4envs_20legal_actions_cython_1legal_actions_cython(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_board_size; + __Pyx_memviewslice __pyx_v_board = { 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("legal_actions_cython (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_board_size,&__pyx_n_s_board,0}; + PyObject* values[2] = {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 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_board_size)) != 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_board)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("legal_actions_cython", 1, 2, 2, 1); __PYX_ERR(0, 6, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "legal_actions_cython") < 0)) __PYX_ERR(0, 6, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 2) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + } + __pyx_v_board_size = __Pyx_PyInt_As_int(values[0]); if (unlikely((__pyx_v_board_size == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 6, __pyx_L3_error) + __pyx_v_board = __Pyx_PyObject_to_MemoryviewSlice_dsds_nn_int32_t(values[1], PyBUF_WRITABLE); if (unlikely(!__pyx_v_board.memview)) __PYX_ERR(0, 6, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("legal_actions_cython", 1, 2, 2, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 6, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("zoo.board_games.gomoku.envs.legal_actions_cython.legal_actions_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3zoo_11board_games_6gomoku_4envs_20legal_actions_cython_legal_actions_cython(__pyx_self, __pyx_v_board_size, __pyx_v_board); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_3zoo_11board_games_6gomoku_4envs_20legal_actions_cython_legal_actions_cython(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_board_size, __Pyx_memviewslice __pyx_v_board) { + PyObject *__pyx_v_legal_actions = 0; + int __pyx_v_i; + int __pyx_v_j; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + Py_ssize_t __pyx_t_8; + Py_ssize_t __pyx_t_9; + int __pyx_t_10; + int __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("legal_actions_cython", 0); + + /* "zoo/board_games/gomoku/envs/legal_actions_cython.pyx":8 + * def legal_actions_cython(int board_size, int32_t[:, :] board): + * # Use a Python list to store possible legal actions + * cdef list legal_actions = [] # <<<<<<<<<<<<<< + * cdef int i, j + * + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_legal_actions = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "zoo/board_games/gomoku/envs/legal_actions_cython.pyx":12 + * + * # Iterate over each position on the board + * for i in range(board_size): # <<<<<<<<<<<<<< + * for j in range(board_size): + * # If the current position is empty (value is 0), it is a legal action + */ + __pyx_t_2 = __pyx_v_board_size; + __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; + + /* "zoo/board_games/gomoku/envs/legal_actions_cython.pyx":13 + * # Iterate over each position on the board + * for i in range(board_size): + * for j in range(board_size): # <<<<<<<<<<<<<< + * # If the current position is empty (value is 0), it is a legal action + * if board[i, j] == 0: + */ + __pyx_t_5 = __pyx_v_board_size; + __pyx_t_6 = __pyx_t_5; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_v_j = __pyx_t_7; + + /* "zoo/board_games/gomoku/envs/legal_actions_cython.pyx":15 + * for j in range(board_size): + * # If the current position is empty (value is 0), it is a legal action + * if board[i, j] == 0: # <<<<<<<<<<<<<< + * # Add the legal action to the list, representing it as an integer + * legal_actions.append(i * board_size + j) + */ + __pyx_t_8 = __pyx_v_i; + __pyx_t_9 = __pyx_v_j; + __pyx_t_10 = (((*((int32_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_board.data + __pyx_t_8 * __pyx_v_board.strides[0]) ) + __pyx_t_9 * __pyx_v_board.strides[1]) ))) == 0) != 0); + if (__pyx_t_10) { + + /* "zoo/board_games/gomoku/envs/legal_actions_cython.pyx":17 + * if board[i, j] == 0: + * # Add the legal action to the list, representing it as an integer + * legal_actions.append(i * board_size + j) # <<<<<<<<<<<<<< + * + * # Return the Python list containing all legal actions + */ + __pyx_t_1 = __Pyx_PyInt_From_int(((__pyx_v_i * __pyx_v_board_size) + __pyx_v_j)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_legal_actions, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "zoo/board_games/gomoku/envs/legal_actions_cython.pyx":15 + * for j in range(board_size): + * # If the current position is empty (value is 0), it is a legal action + * if board[i, j] == 0: # <<<<<<<<<<<<<< + * # Add the legal action to the list, representing it as an integer + * legal_actions.append(i * board_size + j) + */ + } + } + } + + /* "zoo/board_games/gomoku/envs/legal_actions_cython.pyx":20 + * + * # Return the Python list containing all legal actions + * return legal_actions # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_legal_actions); + __pyx_r = __pyx_v_legal_actions; + goto __pyx_L0; + + /* "zoo/board_games/gomoku/envs/legal_actions_cython.pyx":6 + * @cython.boundscheck(False) # Disable bounds checking for performance + * @cython.wraparound(False) # Disable negative indexing for performance + * def legal_actions_cython(int board_size, int32_t[:, :] board): # <<<<<<<<<<<<<< + * # Use a Python list to store possible legal actions + * cdef list legal_actions = [] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("zoo.board_games.gomoku.envs.legal_actions_cython.legal_actions_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_legal_actions); + __PYX_XDEC_MEMVIEW(&__pyx_v_board, 1); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":123 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): + * + */ + +/* Python wrapper */ +static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_shape = 0; + Py_ssize_t __pyx_v_itemsize; + PyObject *__pyx_v_format = 0; + PyObject *__pyx_v_mode = 0; + int __pyx_v_allocate_buffer; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shape,&__pyx_n_s_itemsize,&__pyx_n_s_format,&__pyx_n_s_mode,&__pyx_n_s_allocate_buffer,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[3] = ((PyObject *)__pyx_n_s_c); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shape)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_itemsize)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(1, 123, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_format)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(1, 123, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_allocate_buffer); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 123, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_shape = ((PyObject*)values[0]); + __pyx_v_itemsize = __Pyx_PyIndex_AsSsize_t(values[1]); if (unlikely((__pyx_v_itemsize == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 123, __pyx_L3_error) + __pyx_v_format = values[2]; + __pyx_v_mode = values[3]; + if (values[4]) { + __pyx_v_allocate_buffer = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_allocate_buffer == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 124, __pyx_L3_error) + } else { + + /* "View.MemoryView":124 + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, + * mode="c", bint allocate_buffer=True): # <<<<<<<<<<<<<< + * + * cdef int idx + */ + __pyx_v_allocate_buffer = ((int)1); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 123, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_shape), (&PyTuple_Type), 1, "shape", 1))) __PYX_ERR(1, 123, __pyx_L1_error) + if (unlikely(((PyObject *)__pyx_v_format) == Py_None)) { + PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "format"); __PYX_ERR(1, 123, __pyx_L1_error) + } + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v_shape, __pyx_v_itemsize, __pyx_v_format, __pyx_v_mode, __pyx_v_allocate_buffer); + + /* "View.MemoryView":123 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): + * + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer) { + int __pyx_v_idx; + Py_ssize_t __pyx_v_i; + Py_ssize_t __pyx_v_dim; + PyObject **__pyx_v_p; + char __pyx_v_order; + int __pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + char *__pyx_t_7; + int __pyx_t_8; + Py_ssize_t __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + Py_ssize_t __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + __Pyx_INCREF(__pyx_v_format); + + /* "View.MemoryView":130 + * cdef PyObject **p + * + * self.ndim = len(shape) # <<<<<<<<<<<<<< + * self.itemsize = itemsize + * + */ + if (unlikely(__pyx_v_shape == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 130, __pyx_L1_error) + } + __pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 130, __pyx_L1_error) + __pyx_v_self->ndim = ((int)__pyx_t_1); + + /* "View.MemoryView":131 + * + * self.ndim = len(shape) + * self.itemsize = itemsize # <<<<<<<<<<<<<< + * + * if not self.ndim: + */ + __pyx_v_self->itemsize = __pyx_v_itemsize; + + /* "View.MemoryView":133 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError("Empty shape tuple for cython.array") + * + */ + __pyx_t_2 = ((!(__pyx_v_self->ndim != 0)) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":134 + * + * if not self.ndim: + * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< + * + * if itemsize <= 0: + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 134, __pyx_L1_error) + + /* "View.MemoryView":133 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError("Empty shape tuple for cython.array") + * + */ + } + + /* "View.MemoryView":136 + * raise ValueError("Empty shape tuple for cython.array") + * + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError("itemsize <= 0 for cython.array") + * + */ + __pyx_t_2 = ((__pyx_v_itemsize <= 0) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":137 + * + * if itemsize <= 0: + * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< + * + * if not isinstance(format, bytes): + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 137, __pyx_L1_error) + + /* "View.MemoryView":136 + * raise ValueError("Empty shape tuple for cython.array") + * + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError("itemsize <= 0 for cython.array") + * + */ + } + + /* "View.MemoryView":139 + * raise ValueError("itemsize <= 0 for cython.array") + * + * if not isinstance(format, bytes): # <<<<<<<<<<<<<< + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string + */ + __pyx_t_2 = PyBytes_Check(__pyx_v_format); + __pyx_t_4 = ((!(__pyx_t_2 != 0)) != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":140 + * + * if not isinstance(format, bytes): + * format = format.encode('ASCII') # <<<<<<<<<<<<<< + * self._format = format # keep a reference to the byte string + * self.format = self._format + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_n_s_ASCII) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_n_s_ASCII); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":139 + * raise ValueError("itemsize <= 0 for cython.array") + * + * if not isinstance(format, bytes): # <<<<<<<<<<<<<< + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string + */ + } + + /* "View.MemoryView":141 + * if not isinstance(format, bytes): + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string # <<<<<<<<<<<<<< + * self.format = self._format + * + */ + if (!(likely(PyBytes_CheckExact(__pyx_v_format))||((__pyx_v_format) == Py_None)||((void)PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v_format)->tp_name), 0))) __PYX_ERR(1, 141, __pyx_L1_error) + __pyx_t_3 = __pyx_v_format; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->_format); + __Pyx_DECREF(__pyx_v_self->_format); + __pyx_v_self->_format = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":142 + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string + * self.format = self._format # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(__pyx_v_self->_format == Py_None)) { + PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); + __PYX_ERR(1, 142, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(1, 142, __pyx_L1_error) + __pyx_v_self->format = __pyx_t_7; + + /* "View.MemoryView":145 + * + * + * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) # <<<<<<<<<<<<<< + * self._strides = self._shape + self.ndim + * + */ + __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2))); + + /* "View.MemoryView":146 + * + * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) + * self._strides = self._shape + self.ndim # <<<<<<<<<<<<<< + * + * if not self._shape: + */ + __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim); + + /* "View.MemoryView":148 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate shape and strides.") + * + */ + __pyx_t_4 = ((!(__pyx_v_self->_shape != 0)) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":149 + * + * if not self._shape: + * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 149, __pyx_L1_error) + + /* "View.MemoryView":148 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate shape and strides.") + * + */ + } + + /* "View.MemoryView":152 + * + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + */ + __pyx_t_8 = 0; + __pyx_t_3 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0; + for (;;) { + if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(1, 152, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 152, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_dim = __pyx_t_9; + __pyx_v_idx = __pyx_t_8; + __pyx_t_8 = (__pyx_t_8 + 1); + + /* "View.MemoryView":153 + * + * for idx, dim in enumerate(shape): + * if dim <= 0: # <<<<<<<<<<<<<< + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim + */ + __pyx_t_4 = ((__pyx_v_dim <= 0) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":154 + * for idx, dim in enumerate(shape): + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) # <<<<<<<<<<<<<< + * self._shape[idx] = dim + * + */ + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_6); + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 154, __pyx_L1_error) + + /* "View.MemoryView":153 + * + * for idx, dim in enumerate(shape): + * if dim <= 0: # <<<<<<<<<<<<<< + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim + */ + } + + /* "View.MemoryView":155 + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim # <<<<<<<<<<<<<< + * + * cdef char order + */ + (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim; + + /* "View.MemoryView":152 + * + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":158 + * + * cdef char order + * if mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' + */ + __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 158, __pyx_L1_error) + if (__pyx_t_4) { + + /* "View.MemoryView":159 + * cdef char order + * if mode == 'fortran': + * order = b'F' # <<<<<<<<<<<<<< + * self.mode = u'fortran' + * elif mode == 'c': + */ + __pyx_v_order = 'F'; + + /* "View.MemoryView":160 + * if mode == 'fortran': + * order = b'F' + * self.mode = u'fortran' # <<<<<<<<<<<<<< + * elif mode == 'c': + * order = b'C' + */ + __Pyx_INCREF(__pyx_n_u_fortran); + __Pyx_GIVEREF(__pyx_n_u_fortran); + __Pyx_GOTREF(__pyx_v_self->mode); + __Pyx_DECREF(__pyx_v_self->mode); + __pyx_v_self->mode = __pyx_n_u_fortran; + + /* "View.MemoryView":158 + * + * cdef char order + * if mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' + */ + goto __pyx_L10; + } + + /* "View.MemoryView":161 + * order = b'F' + * self.mode = u'fortran' + * elif mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' + */ + __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_c, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 161, __pyx_L1_error) + if (likely(__pyx_t_4)) { + + /* "View.MemoryView":162 + * self.mode = u'fortran' + * elif mode == 'c': + * order = b'C' # <<<<<<<<<<<<<< + * self.mode = u'c' + * else: + */ + __pyx_v_order = 'C'; + + /* "View.MemoryView":163 + * elif mode == 'c': + * order = b'C' + * self.mode = u'c' # <<<<<<<<<<<<<< + * else: + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) + */ + __Pyx_INCREF(__pyx_n_u_c); + __Pyx_GIVEREF(__pyx_n_u_c); + __Pyx_GOTREF(__pyx_v_self->mode); + __Pyx_DECREF(__pyx_v_self->mode); + __pyx_v_self->mode = __pyx_n_u_c; + + /* "View.MemoryView":161 + * order = b'F' + * self.mode = u'fortran' + * elif mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' + */ + goto __pyx_L10; + } + + /* "View.MemoryView":165 + * self.mode = u'c' + * else: + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) # <<<<<<<<<<<<<< + * + * self.len = fill_contig_strides_array(self._shape, self._strides, + */ + /*else*/ { + __pyx_t_3 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_v_mode); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 165, __pyx_L1_error) + } + __pyx_L10:; + + /* "View.MemoryView":167 + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) + * + * self.len = fill_contig_strides_array(self._shape, self._strides, # <<<<<<<<<<<<<< + * itemsize, self.ndim, order) + * + */ + __pyx_v_self->len = __pyx_fill_contig_strides_array(__pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_itemsize, __pyx_v_self->ndim, __pyx_v_order); + + /* "View.MemoryView":170 + * itemsize, self.ndim, order) + * + * self.free_data = allocate_buffer # <<<<<<<<<<<<<< + * self.dtype_is_object = format == b'O' + * if allocate_buffer: + */ + __pyx_v_self->free_data = __pyx_v_allocate_buffer; + + /* "View.MemoryView":171 + * + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<< + * if allocate_buffer: + * + */ + __pyx_t_10 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 171, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 171, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_v_self->dtype_is_object = __pyx_t_4; + + /* "View.MemoryView":172 + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' + * if allocate_buffer: # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = (__pyx_v_allocate_buffer != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":175 + * + * + * self.data = malloc(self.len) # <<<<<<<<<<<<<< + * if not self.data: + * raise MemoryError("unable to allocate array data.") + */ + __pyx_v_self->data = ((char *)malloc(__pyx_v_self->len)); + + /* "View.MemoryView":176 + * + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate array data.") + * + */ + __pyx_t_4 = ((!(__pyx_v_self->data != 0)) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":177 + * self.data = malloc(self.len) + * if not self.data: + * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< + * + * if self.dtype_is_object: + */ + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 177, __pyx_L1_error) + + /* "View.MemoryView":176 + * + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate array data.") + * + */ + } + + /* "View.MemoryView":179 + * raise MemoryError("unable to allocate array data.") + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len / itemsize): + */ + __pyx_t_4 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":180 + * + * if self.dtype_is_object: + * p = self.data # <<<<<<<<<<<<<< + * for i in range(self.len / itemsize): + * p[i] = Py_None + */ + __pyx_v_p = ((PyObject **)__pyx_v_self->data); + + /* "View.MemoryView":181 + * if self.dtype_is_object: + * p = self.data + * for i in range(self.len / itemsize): # <<<<<<<<<<<<<< + * p[i] = Py_None + * Py_INCREF(Py_None) + */ + if (unlikely(__pyx_v_itemsize == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); + __PYX_ERR(1, 181, __pyx_L1_error) + } + else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) { + PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); + __PYX_ERR(1, 181, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_itemsize); + __pyx_t_9 = __pyx_t_1; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_9; __pyx_t_11+=1) { + __pyx_v_i = __pyx_t_11; + + /* "View.MemoryView":182 + * p = self.data + * for i in range(self.len / itemsize): + * p[i] = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * + */ + (__pyx_v_p[__pyx_v_i]) = Py_None; + + /* "View.MemoryView":183 + * for i in range(self.len / itemsize): + * p[i] = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + Py_INCREF(Py_None); + } + + /* "View.MemoryView":179 + * raise MemoryError("unable to allocate array data.") + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len / itemsize): + */ + } + + /* "View.MemoryView":172 + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' + * if allocate_buffer: # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":123 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_format); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":186 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * cdef int bufmode = -1 + * if self.mode == u"c": + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(((struct __pyx_array_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_bufmode; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + char *__pyx_t_4; + Py_ssize_t __pyx_t_5; + int __pyx_t_6; + Py_ssize_t *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + if (__pyx_v_info == NULL) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + + /* "View.MemoryView":187 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 # <<<<<<<<<<<<<< + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + */ + __pyx_v_bufmode = -1; + + /* "View.MemoryView":188 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + */ + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_c, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 188, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":189 + * cdef int bufmode = -1 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + */ + __pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); + + /* "View.MemoryView":188 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + */ + goto __pyx_L3; + } + + /* "View.MemoryView":190 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": # <<<<<<<<<<<<<< + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + */ + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 190, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":191 + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") + */ + __pyx_v_bufmode = (PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); + + /* "View.MemoryView":190 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": # <<<<<<<<<<<<<< + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + */ + } + __pyx_L3:; + + /* "View.MemoryView":192 + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): # <<<<<<<<<<<<<< + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data + */ + __pyx_t_1 = ((!((__pyx_v_flags & __pyx_v_bufmode) != 0)) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":193 + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") # <<<<<<<<<<<<<< + * info.buf = self.data + * info.len = self.len + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 193, __pyx_L1_error) + + /* "View.MemoryView":192 + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): # <<<<<<<<<<<<<< + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data + */ + } + + /* "View.MemoryView":194 + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data # <<<<<<<<<<<<<< + * info.len = self.len + * info.ndim = self.ndim + */ + __pyx_t_4 = __pyx_v_self->data; + __pyx_v_info->buf = __pyx_t_4; + + /* "View.MemoryView":195 + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data + * info.len = self.len # <<<<<<<<<<<<<< + * info.ndim = self.ndim + * info.shape = self._shape + */ + __pyx_t_5 = __pyx_v_self->len; + __pyx_v_info->len = __pyx_t_5; + + /* "View.MemoryView":196 + * info.buf = self.data + * info.len = self.len + * info.ndim = self.ndim # <<<<<<<<<<<<<< + * info.shape = self._shape + * info.strides = self._strides + */ + __pyx_t_6 = __pyx_v_self->ndim; + __pyx_v_info->ndim = __pyx_t_6; + + /* "View.MemoryView":197 + * info.len = self.len + * info.ndim = self.ndim + * info.shape = self._shape # <<<<<<<<<<<<<< + * info.strides = self._strides + * info.suboffsets = NULL + */ + __pyx_t_7 = __pyx_v_self->_shape; + __pyx_v_info->shape = __pyx_t_7; + + /* "View.MemoryView":198 + * info.ndim = self.ndim + * info.shape = self._shape + * info.strides = self._strides # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = self.itemsize + */ + __pyx_t_7 = __pyx_v_self->_strides; + __pyx_v_info->strides = __pyx_t_7; + + /* "View.MemoryView":199 + * info.shape = self._shape + * info.strides = self._strides + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = self.itemsize + * info.readonly = 0 + */ + __pyx_v_info->suboffsets = NULL; + + /* "View.MemoryView":200 + * info.strides = self._strides + * info.suboffsets = NULL + * info.itemsize = self.itemsize # <<<<<<<<<<<<<< + * info.readonly = 0 + * + */ + __pyx_t_5 = __pyx_v_self->itemsize; + __pyx_v_info->itemsize = __pyx_t_5; + + /* "View.MemoryView":201 + * info.suboffsets = NULL + * info.itemsize = self.itemsize + * info.readonly = 0 # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + __pyx_v_info->readonly = 0; + + /* "View.MemoryView":203 + * info.readonly = 0 + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.format + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":204 + * + * if flags & PyBUF_FORMAT: + * info.format = self.format # <<<<<<<<<<<<<< + * else: + * info.format = NULL + */ + __pyx_t_4 = __pyx_v_self->format; + __pyx_v_info->format = __pyx_t_4; + + /* "View.MemoryView":203 + * info.readonly = 0 + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.format + * else: + */ + goto __pyx_L5; + } + + /* "View.MemoryView":206 + * info.format = self.format + * else: + * info.format = NULL # <<<<<<<<<<<<<< + * + * info.obj = self + */ + /*else*/ { + __pyx_v_info->format = NULL; + } + __pyx_L5:; + + /* "View.MemoryView":208 + * info.format = NULL + * + * info.obj = self # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + */ + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + + /* "View.MemoryView":186 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * cdef int bufmode = -1 + * if self.mode == u"c": + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.array.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":212 + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + * + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + */ + +/* Python wrapper */ +static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_array___dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":213 + * + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data: + */ + __pyx_t_1 = ((__pyx_v_self->callback_free_data != NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":214 + * def __dealloc__(array self): + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) # <<<<<<<<<<<<<< + * elif self.free_data: + * if self.dtype_is_object: + */ + __pyx_v_self->callback_free_data(__pyx_v_self->data); + + /* "View.MemoryView":213 + * + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":215 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, + */ + __pyx_t_1 = (__pyx_v_self->free_data != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":216 + * self.callback_free_data(self.data) + * elif self.free_data: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + */ + __pyx_t_1 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":217 + * elif self.free_data: + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, # <<<<<<<<<<<<<< + * self._strides, self.ndim, False) + * free(self.data) + */ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_self->data, __pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_self->ndim, 0); + + /* "View.MemoryView":216 + * self.callback_free_data(self.data) + * elif self.free_data: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + */ + } + + /* "View.MemoryView":219 + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + * free(self.data) # <<<<<<<<<<<<<< + * PyObject_Free(self._shape) + * + */ + free(__pyx_v_self->data); + + /* "View.MemoryView":215 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, + */ + } + __pyx_L3:; + + /* "View.MemoryView":220 + * self._strides, self.ndim, False) + * free(self.data) + * PyObject_Free(self._shape) # <<<<<<<<<<<<<< + * + * @property + */ + PyObject_Free(__pyx_v_self->_shape); + + /* "View.MemoryView":212 + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + * + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":223 + * + * @property + * def memview(self): # <<<<<<<<<<<<<< + * return self.get_memview() + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_5array_7memview___get__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":224 + * @property + * def memview(self): + * return self.get_memview() # <<<<<<<<<<<<<< + * + * @cname('get_memview') + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_array *)__pyx_v_self->__pyx_vtab)->get_memview(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":223 + * + * @property + * def memview(self): # <<<<<<<<<<<<<< + * return self.get_memview() + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.memview.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":227 + * + * @cname('get_memview') + * cdef get_memview(self): # <<<<<<<<<<<<<< + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) + */ + +static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) { + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_memview", 0); + + /* "View.MemoryView":228 + * @cname('get_memview') + * cdef get_memview(self): + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE # <<<<<<<<<<<<<< + * return memoryview(self, flags, self.dtype_is_object) + * + */ + __pyx_v_flags = ((PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) | PyBUF_WRITABLE); + + /* "View.MemoryView":229 + * cdef get_memview(self): + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) # <<<<<<<<<<<<<< + * + * def __len__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":227 + * + * @cname('get_memview') + * cdef get_memview(self): # <<<<<<<<<<<<<< + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.array.get_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":231 + * return memoryview(self, flags, self.dtype_is_object) + * + * def __len__(self): # <<<<<<<<<<<<<< + * return self._shape[0] + * + */ + +/* Python wrapper */ +static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self); /*proto*/ +static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__", 0); + + /* "View.MemoryView":232 + * + * def __len__(self): + * return self._shape[0] # <<<<<<<<<<<<<< + * + * def __getattr__(self, attr): + */ + __pyx_r = (__pyx_v_self->_shape[0]); + goto __pyx_L0; + + /* "View.MemoryView":231 + * return memoryview(self, flags, self.dtype_is_object) + * + * def __len__(self): # <<<<<<<<<<<<<< + * return self._shape[0] + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":234 + * return self._shape[0] + * + * def __getattr__(self, attr): # <<<<<<<<<<<<<< + * return getattr(self.memview, attr) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr); /*proto*/ +static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_attr)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getattr__", 0); + + /* "View.MemoryView":235 + * + * def __getattr__(self, attr): + * return getattr(self.memview, attr) # <<<<<<<<<<<<<< + * + * def __getitem__(self, item): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_GetAttr(__pyx_t_1, __pyx_v_attr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":234 + * return self._shape[0] + * + * def __getattr__(self, attr): # <<<<<<<<<<<<<< + * return getattr(self.memview, attr) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.array.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":237 + * return getattr(self.memview, attr) + * + * def __getitem__(self, item): # <<<<<<<<<<<<<< + * return self.memview[item] + * + */ + +/* Python wrapper */ +static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/ +static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "View.MemoryView":238 + * + * def __getitem__(self, item): + * return self.memview[item] # <<<<<<<<<<<<<< + * + * def __setitem__(self, item, value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":237 + * return getattr(self.memview, attr) + * + * def __getitem__(self, item): # <<<<<<<<<<<<<< + * return self.memview[item] + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":240 + * return self.memview[item] + * + * def __setitem__(self, item, value): # <<<<<<<<<<<<<< + * self.memview[item] = value + * + */ + +/* Python wrapper */ +static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + + /* "View.MemoryView":241 + * + * def __setitem__(self, item, value): + * self.memview[item] = value # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_item, __pyx_v_value) < 0)) __PYX_ERR(1, 241, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":240 + * return self.memview[item] + * + * def __setitem__(self, item, value): # <<<<<<<<<<<<<< + * self.memview[item] = value + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__6, 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__7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":245 + * + * @cname("__pyx_array_new") + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< + * char *mode, char *buf): + * cdef array result + */ + +static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, char *__pyx_v_format, char *__pyx_v_mode, char *__pyx_v_buf) { + struct __pyx_array_obj *__pyx_v_result = 0; + struct __pyx_array_obj *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("array_cwrapper", 0); + + /* "View.MemoryView":249 + * cdef array result + * + * if buf == NULL: # <<<<<<<<<<<<<< + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + */ + __pyx_t_1 = ((__pyx_v_buf == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":250 + * + * if buf == NULL: + * result = array(shape, itemsize, format, mode.decode('ASCII')) # <<<<<<<<<<<<<< + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), + */ + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_shape); + __Pyx_GIVEREF(__pyx_v_shape); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_shape); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":249 + * cdef array result + * + * if buf == NULL: # <<<<<<<<<<<<<< + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":252 + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< + * allocate_buffer=False) + * result.data = buf + */ + /*else*/ { + __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_shape); + __Pyx_GIVEREF(__pyx_v_shape); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_shape); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_3 = 0; + + /* "View.MemoryView":253 + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), + * allocate_buffer=False) # <<<<<<<<<<<<<< + * result.data = buf + * + */ + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 253, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(1, 253, __pyx_L1_error) + + /* "View.MemoryView":252 + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< + * allocate_buffer=False) + * result.data = buf + */ + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_5); + __pyx_t_5 = 0; + + /* "View.MemoryView":254 + * result = array(shape, itemsize, format, mode.decode('ASCII'), + * allocate_buffer=False) + * result.data = buf # <<<<<<<<<<<<<< + * + * return result + */ + __pyx_v_result->data = __pyx_v_buf; + } + __pyx_L3:; + + /* "View.MemoryView":256 + * result.data = buf + * + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "View.MemoryView":245 + * + * @cname("__pyx_array_new") + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< + * char *mode, char *buf): + * cdef array result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":282 + * cdef class Enum(object): + * cdef object name + * def __init__(self, name): # <<<<<<<<<<<<<< + * self.name = name + * def __repr__(self): + */ + +/* Python wrapper */ +static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_name = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 282, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_name = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 282, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.Enum.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v_name); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__", 0); + + /* "View.MemoryView":283 + * cdef object name + * def __init__(self, name): + * self.name = name # <<<<<<<<<<<<<< + * def __repr__(self): + * return self.name + */ + __Pyx_INCREF(__pyx_v_name); + __Pyx_GIVEREF(__pyx_v_name); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = __pyx_v_name; + + /* "View.MemoryView":282 + * cdef class Enum(object): + * cdef object name + * def __init__(self, name): # <<<<<<<<<<<<<< + * self.name = name + * def __repr__(self): + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":284 + * def __init__(self, name): + * self.name = name + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name + * + */ + +/* Python wrapper */ +static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "View.MemoryView":285 + * self.name = name + * def __repr__(self): + * return self.name # <<<<<<<<<<<<<< + * + * cdef generic = Enum("") + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->name); + __pyx_r = __pyx_v_self->name; + goto __pyx_L0; + + /* "View.MemoryView":284 + * def __init__(self, name): + * self.name = name + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_MemviewEnum___reduce_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.name,) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->name); + __Pyx_GIVEREF(__pyx_v_self->name); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict); + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.name is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.name is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + */ + /*else*/ { + __pyx_t_3 = (__pyx_v_self->name != Py_None); + __pyx_v_use_setstate = __pyx_t_3; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + */ + __pyx_t_3 = (__pyx_v_use_setstate != 0); + if (__pyx_t_3) { + + /* "(tree fragment)":13 + * use_setstate = self.name is not None + * if use_setstate: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_INCREF(__pyx_int_184977713); + __Pyx_GIVEREF(__pyx_int_184977713); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Enum__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_INCREF(__pyx_int_184977713); + __Pyx_GIVEREF(__pyx_int_184977713); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.Enum.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Enum__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||((void)PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_unpickle_Enum__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":299 + * + * @cname('__pyx_align_pointer') + * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory + */ + +static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) { + Py_intptr_t __pyx_v_aligned_p; + size_t __pyx_v_offset; + void *__pyx_r; + int __pyx_t_1; + + /* "View.MemoryView":301 + * cdef void *align_pointer(void *memory, size_t alignment) nogil: + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory # <<<<<<<<<<<<<< + * cdef size_t offset + * + */ + __pyx_v_aligned_p = ((Py_intptr_t)__pyx_v_memory); + + /* "View.MemoryView":305 + * + * with cython.cdivision(True): + * offset = aligned_p % alignment # <<<<<<<<<<<<<< + * + * if offset > 0: + */ + __pyx_v_offset = (__pyx_v_aligned_p % __pyx_v_alignment); + + /* "View.MemoryView":307 + * offset = aligned_p % alignment + * + * if offset > 0: # <<<<<<<<<<<<<< + * aligned_p += alignment - offset + * + */ + __pyx_t_1 = ((__pyx_v_offset > 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":308 + * + * if offset > 0: + * aligned_p += alignment - offset # <<<<<<<<<<<<<< + * + * return aligned_p + */ + __pyx_v_aligned_p = (__pyx_v_aligned_p + (__pyx_v_alignment - __pyx_v_offset)); + + /* "View.MemoryView":307 + * offset = aligned_p % alignment + * + * if offset > 0: # <<<<<<<<<<<<<< + * aligned_p += alignment - offset + * + */ + } + + /* "View.MemoryView":310 + * aligned_p += alignment - offset + * + * return aligned_p # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((void *)__pyx_v_aligned_p); + goto __pyx_L0; + + /* "View.MemoryView":299 + * + * @cname('__pyx_align_pointer') + * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":346 + * cdef __Pyx_TypeInfo *typeinfo + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< + * self.obj = obj + * self.flags = flags + */ + +/* Python wrapper */ +static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_obj = 0; + int __pyx_v_flags; + int __pyx_v_dtype_is_object; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_obj)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 346, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dtype_is_object); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 346, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_obj = values[0]; + __pyx_v_flags = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 346, __pyx_L3_error) + if (values[2]) { + __pyx_v_dtype_is_object = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_dtype_is_object == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 346, __pyx_L3_error) + } else { + __pyx_v_dtype_is_object = ((int)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 346, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_obj, __pyx_v_flags, __pyx_v_dtype_is_object); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "View.MemoryView":347 + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): + * self.obj = obj # <<<<<<<<<<<<<< + * self.flags = flags + * if type(self) is memoryview or obj is not None: + */ + __Pyx_INCREF(__pyx_v_obj); + __Pyx_GIVEREF(__pyx_v_obj); + __Pyx_GOTREF(__pyx_v_self->obj); + __Pyx_DECREF(__pyx_v_self->obj); + __pyx_v_self->obj = __pyx_v_obj; + + /* "View.MemoryView":348 + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): + * self.obj = obj + * self.flags = flags # <<<<<<<<<<<<<< + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) + */ + __pyx_v_self->flags = __pyx_v_flags; + + /* "View.MemoryView":349 + * self.obj = obj + * self.flags = flags + * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: + */ + __pyx_t_2 = (((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))) == ((PyObject *)__pyx_memoryview_type)); + __pyx_t_3 = (__pyx_t_2 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = (__pyx_v_obj != Py_None); + __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "View.MemoryView":350 + * self.flags = flags + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) # <<<<<<<<<<<<<< + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None + */ + __pyx_t_4 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 350, __pyx_L1_error) + + /* "View.MemoryView":351 + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) + */ + __pyx_t_1 = ((((PyObject *)__pyx_v_self->view.obj) == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":352 + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * + */ + ((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None; + + /* "View.MemoryView":353 + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + */ + Py_INCREF(Py_None); + + /* "View.MemoryView":351 + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) + */ + } + + /* "View.MemoryView":349 + * self.obj = obj + * self.flags = flags + * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: + */ + } + + /* "View.MemoryView":355 + * Py_INCREF(Py_None) + * + * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + */ + __pyx_t_1 = ((!(__PYX_CYTHON_ATOMICS_ENABLED() != 0)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":357 + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + */ + __pyx_t_1 = ((__pyx_memoryview_thread_locks_used < 8) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":358 + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: + */ + __pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); + + /* "View.MemoryView":359 + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 # <<<<<<<<<<<<<< + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + */ + __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1); + + /* "View.MemoryView":357 + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + */ + } + + /* "View.MemoryView":360 + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: # <<<<<<<<<<<<<< + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + */ + __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":361 + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() # <<<<<<<<<<<<<< + * if self.lock is NULL: + * raise MemoryError + */ + __pyx_v_self->lock = PyThread_allocate_lock(); + + /* "View.MemoryView":362 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * + */ + __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":363 + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + PyErr_NoMemory(); __PYX_ERR(1, 363, __pyx_L1_error) + + /* "View.MemoryView":362 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * + */ + } + + /* "View.MemoryView":360 + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: # <<<<<<<<<<<<<< + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + */ + } + + /* "View.MemoryView":355 + * Py_INCREF(Py_None) + * + * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + */ + } + + /* "View.MemoryView":365 + * raise MemoryError + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":366 + * + * if flags & PyBUF_FORMAT: + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') # <<<<<<<<<<<<<< + * else: + * self.dtype_is_object = dtype_is_object + */ + __pyx_t_2 = (((__pyx_v_self->view.format[0]) == 'O') != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L12_bool_binop_done; + } + __pyx_t_2 = (((__pyx_v_self->view.format[1]) == '\x00') != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L12_bool_binop_done:; + __pyx_v_self->dtype_is_object = __pyx_t_1; + + /* "View.MemoryView":365 + * raise MemoryError + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: + */ + goto __pyx_L11; + } + + /* "View.MemoryView":368 + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: + * self.dtype_is_object = dtype_is_object # <<<<<<<<<<<<<< + * + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( + */ + /*else*/ { + __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object; + } + __pyx_L11:; + + /* "View.MemoryView":370 + * self.dtype_is_object = dtype_is_object + * + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( # <<<<<<<<<<<<<< + * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) + * self.typeinfo = NULL + */ + __pyx_v_self->acquisition_count_aligned_p = ((__pyx_atomic_int *)__pyx_align_pointer(((void *)(&(__pyx_v_self->acquisition_count[0]))), (sizeof(__pyx_atomic_int)))); + + /* "View.MemoryView":372 + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( + * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) + * self.typeinfo = NULL # <<<<<<<<<<<<<< + * + * def __dealloc__(memoryview self): + */ + __pyx_v_self->typeinfo = NULL; + + /* "View.MemoryView":346 + * cdef __Pyx_TypeInfo *typeinfo + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< + * self.obj = obj + * self.flags = flags + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":374 + * self.typeinfo = NULL + * + * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + */ + +/* Python wrapper */ +static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self) { + int __pyx_v_i; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyThread_type_lock __pyx_t_6; + PyThread_type_lock __pyx_t_7; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":375 + * + * def __dealloc__(memoryview self): + * if self.obj is not None: # <<<<<<<<<<<<<< + * __Pyx_ReleaseBuffer(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + */ + __pyx_t_1 = (__pyx_v_self->obj != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":376 + * def __dealloc__(memoryview self): + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) # <<<<<<<<<<<<<< + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + * + */ + __Pyx_ReleaseBuffer((&__pyx_v_self->view)); + + /* "View.MemoryView":375 + * + * def __dealloc__(memoryview self): + * if self.obj is not None: # <<<<<<<<<<<<<< + * __Pyx_ReleaseBuffer(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":377 + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< + * + * (<__pyx_buffer *> &self.view).obj = NULL + */ + __pyx_t_2 = ((((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":379 + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + * + * (<__pyx_buffer *> &self.view).obj = NULL # <<<<<<<<<<<<<< + * Py_DECREF(Py_None) + * + */ + ((Py_buffer *)(&__pyx_v_self->view))->obj = NULL; + + /* "View.MemoryView":380 + * + * (<__pyx_buffer *> &self.view).obj = NULL + * Py_DECREF(Py_None) # <<<<<<<<<<<<<< + * + * cdef int i + */ + Py_DECREF(Py_None); + + /* "View.MemoryView":377 + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< + * + * (<__pyx_buffer *> &self.view).obj = NULL + */ + } + __pyx_L3:; + + /* "View.MemoryView":384 + * cdef int i + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: # <<<<<<<<<<<<<< + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: + */ + __pyx_t_2 = ((__pyx_v_self->lock != NULL) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":385 + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: + * for i in range(__pyx_memoryview_thread_locks_used): # <<<<<<<<<<<<<< + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + */ + __pyx_t_3 = __pyx_memoryview_thread_locks_used; + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "View.MemoryView":386 + * if self.lock != NULL: + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + */ + __pyx_t_2 = (((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":387 + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 # <<<<<<<<<<<<<< + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + */ + __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used - 1); + + /* "View.MemoryView":388 + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + */ + __pyx_t_2 = ((__pyx_v_i != __pyx_memoryview_thread_locks_used) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":390 + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) # <<<<<<<<<<<<<< + * break + * else: + */ + __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); + __pyx_t_7 = (__pyx_memoryview_thread_locks[__pyx_v_i]); + + /* "View.MemoryView":389 + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + * break + */ + (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_6; + (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_7; + + /* "View.MemoryView":388 + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + */ + } + + /* "View.MemoryView":391 + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + * break # <<<<<<<<<<<<<< + * else: + * PyThread_free_lock(self.lock) + */ + goto __pyx_L6_break; + + /* "View.MemoryView":386 + * if self.lock != NULL: + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + */ + } + } + /*else*/ { + + /* "View.MemoryView":393 + * break + * else: + * PyThread_free_lock(self.lock) # <<<<<<<<<<<<<< + * + * cdef char *get_item_pointer(memoryview self, object index) except NULL: + */ + PyThread_free_lock(__pyx_v_self->lock); + } + __pyx_L6_break:; + + /* "View.MemoryView":384 + * cdef int i + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: # <<<<<<<<<<<<<< + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: + */ + } + + /* "View.MemoryView":374 + * self.typeinfo = NULL + * + * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":395 + * PyThread_free_lock(self.lock) + * + * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf + */ + +static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { + Py_ssize_t __pyx_v_dim; + char *__pyx_v_itemp; + PyObject *__pyx_v_idx = NULL; + char *__pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *(*__pyx_t_4)(PyObject *); + PyObject *__pyx_t_5 = NULL; + Py_ssize_t __pyx_t_6; + char *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_item_pointer", 0); + + /* "View.MemoryView":397 + * cdef char *get_item_pointer(memoryview self, object index) except NULL: + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf # <<<<<<<<<<<<<< + * + * for dim, idx in enumerate(index): + */ + __pyx_v_itemp = ((char *)__pyx_v_self->view.buf); + + /* "View.MemoryView":399 + * cdef char *itemp = self.view.buf + * + * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * + */ + __pyx_t_1 = 0; + if (likely(PyList_CheckExact(__pyx_v_index)) || PyTuple_CheckExact(__pyx_v_index)) { + __pyx_t_2 = __pyx_v_index; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 399, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 399, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } else { + if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 399, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } + } else { + __pyx_t_5 = __pyx_t_4(__pyx_t_2); + if (unlikely(!__pyx_t_5)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 399, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_v_dim = __pyx_t_1; + __pyx_t_1 = (__pyx_t_1 + 1); + + /* "View.MemoryView":400 + * + * for dim, idx in enumerate(index): + * itemp = pybuffer_index(&self.view, itemp, idx, dim) # <<<<<<<<<<<<<< + * + * return itemp + */ + __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 400, __pyx_L1_error) + __pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(1, 400, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_7; + + /* "View.MemoryView":399 + * cdef char *itemp = self.view.buf + * + * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":402 + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * + * return itemp # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_itemp; + goto __pyx_L0; + + /* "View.MemoryView":395 + * PyThread_free_lock(self.lock) + * + * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.get_item_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_idx); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":405 + * + * + * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< + * if index is Ellipsis: + * return self + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index); /*proto*/ +static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { + PyObject *__pyx_v_have_slices = NULL; + PyObject *__pyx_v_indices = NULL; + char *__pyx_v_itemp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + char *__pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "View.MemoryView":406 + * + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self + * + */ + __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":407 + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: + * return self # <<<<<<<<<<<<<< + * + * have_slices, indices = _unellipsify(index, self.view.ndim) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "View.MemoryView":406 + * + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self + * + */ + } + + /* "View.MemoryView":409 + * return self + * + * have_slices, indices = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< + * + * cdef char *itemp + */ + __pyx_t_3 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (likely(__pyx_t_3 != Py_None)) { + PyObject* sequence = __pyx_t_3; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 409, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + #else + __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 409, __pyx_L1_error) + } + __pyx_v_have_slices = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_v_indices = __pyx_t_5; + __pyx_t_5 = 0; + + /* "View.MemoryView":412 + * + * cdef char *itemp + * if have_slices: # <<<<<<<<<<<<<< + * return memview_slice(self, indices) + * else: + */ + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 412, __pyx_L1_error) + if (__pyx_t_2) { + + /* "View.MemoryView":413 + * cdef char *itemp + * if have_slices: + * return memview_slice(self, indices) # <<<<<<<<<<<<<< + * else: + * itemp = self.get_item_pointer(indices) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":412 + * + * cdef char *itemp + * if have_slices: # <<<<<<<<<<<<<< + * return memview_slice(self, indices) + * else: + */ + } + + /* "View.MemoryView":415 + * return memview_slice(self, indices) + * else: + * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< + * return self.convert_item_to_object(itemp) + * + */ + /*else*/ { + __pyx_t_6 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_6 == ((char *)NULL))) __PYX_ERR(1, 415, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_6; + + /* "View.MemoryView":416 + * else: + * itemp = self.get_item_pointer(indices) + * return self.convert_item_to_object(itemp) # <<<<<<<<<<<<<< + * + * def __setitem__(memoryview self, object index, object value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":405 + * + * + * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< + * if index is Ellipsis: + * return self + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_have_slices); + __Pyx_XDECREF(__pyx_v_indices); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":418 + * return self.convert_item_to_object(itemp) + * + * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") + */ + +/* Python wrapper */ +static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + PyObject *__pyx_v_have_slices = NULL; + PyObject *__pyx_v_obj = NULL; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + __Pyx_INCREF(__pyx_v_index); + + /* "View.MemoryView":419 + * + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError("Cannot assign to read-only memoryview") + * + */ + __pyx_t_1 = (__pyx_v_self->view.readonly != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":420 + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< + * + * have_slices, index = _unellipsify(index, self.view.ndim) + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 420, __pyx_L1_error) + + /* "View.MemoryView":419 + * + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError("Cannot assign to read-only memoryview") + * + */ + } + + /* "View.MemoryView":422 + * raise TypeError("Cannot assign to read-only memoryview") + * + * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< + * + * if have_slices: + */ + __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(__pyx_t_2 != Py_None)) { + PyObject* sequence = __pyx_t_2; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 422, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 422, __pyx_L1_error) + } + __pyx_v_have_slices = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":424 + * have_slices, index = _unellipsify(index, self.view.ndim) + * + * if have_slices: # <<<<<<<<<<<<<< + * obj = self.is_slice(value) + * if obj: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 424, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":425 + * + * if have_slices: + * obj = self.is_slice(value) # <<<<<<<<<<<<<< + * if obj: + * self.setitem_slice_assignment(self[index], obj) + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_obj = __pyx_t_2; + __pyx_t_2 = 0; + + /* "View.MemoryView":426 + * if have_slices: + * obj = self.is_slice(value) + * if obj: # <<<<<<<<<<<<<< + * self.setitem_slice_assignment(self[index], obj) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 426, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":427 + * obj = self.is_slice(value) + * if obj: + * self.setitem_slice_assignment(self[index], obj) # <<<<<<<<<<<<<< + * else: + * self.setitem_slice_assign_scalar(self[index], value) + */ + __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_2, __pyx_v_obj); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":426 + * if have_slices: + * obj = self.is_slice(value) + * if obj: # <<<<<<<<<<<<<< + * self.setitem_slice_assignment(self[index], obj) + * else: + */ + goto __pyx_L5; + } + + /* "View.MemoryView":429 + * self.setitem_slice_assignment(self[index], obj) + * else: + * self.setitem_slice_assign_scalar(self[index], value) # <<<<<<<<<<<<<< + * else: + * self.setitem_indexed(index, value) + */ + /*else*/ { + __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_memoryview_type))))) __PYX_ERR(1, 429, __pyx_L1_error) + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_4), __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L5:; + + /* "View.MemoryView":424 + * have_slices, index = _unellipsify(index, self.view.ndim) + * + * if have_slices: # <<<<<<<<<<<<<< + * obj = self.is_slice(value) + * if obj: + */ + goto __pyx_L4; + } + + /* "View.MemoryView":431 + * self.setitem_slice_assign_scalar(self[index], value) + * else: + * self.setitem_indexed(index, value) # <<<<<<<<<<<<<< + * + * cdef is_slice(self, obj): + */ + /*else*/ { + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 431, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L4:; + + /* "View.MemoryView":418 + * return self.convert_item_to_object(itemp) + * + * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView.memoryview.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_have_slices); + __Pyx_XDECREF(__pyx_v_obj); + __Pyx_XDECREF(__pyx_v_index); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":433 + * self.setitem_indexed(index, value) + * + * cdef is_slice(self, obj): # <<<<<<<<<<<<<< + * if not isinstance(obj, memoryview): + * try: + */ + +static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_slice", 0); + __Pyx_INCREF(__pyx_v_obj); + + /* "View.MemoryView":434 + * + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + */ + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_obj, __pyx_memoryview_type); + __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":435 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + /*try:*/ { + + /* "View.MemoryView":436 + * if not isinstance(obj, memoryview): + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< + * self.dtype_is_object) + * except TypeError: + */ + __pyx_t_6 = __Pyx_PyInt_From_int(((__pyx_v_self->flags & (~PyBUF_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 436, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "View.MemoryView":437 + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) # <<<<<<<<<<<<<< + * except TypeError: + * return None + */ + __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 437, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_7); + + /* "View.MemoryView":436 + * if not isinstance(obj, memoryview): + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< + * self.dtype_is_object) + * except TypeError: + */ + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 436, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_v_obj); + __Pyx_GIVEREF(__pyx_v_obj); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_obj); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7); + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 436, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF_SET(__pyx_v_obj, __pyx_t_7); + __pyx_t_7 = 0; + + /* "View.MemoryView":435 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + */ + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L9_try_end; + __pyx_L4_error:; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "View.MemoryView":438 + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + * except TypeError: # <<<<<<<<<<<<<< + * return None + * + */ + __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); + if (__pyx_t_9) { + __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_6) < 0) __PYX_ERR(1, 438, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_t_6); + + /* "View.MemoryView":439 + * self.dtype_is_object) + * except TypeError: + * return None # <<<<<<<<<<<<<< + * + * return obj + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L7_except_return; + } + goto __pyx_L6_except_error; + __pyx_L6_except_error:; + + /* "View.MemoryView":435 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + */ + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + goto __pyx_L1_error; + __pyx_L7_except_return:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + goto __pyx_L0; + __pyx_L9_try_end:; + } + + /* "View.MemoryView":434 + * + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + */ + } + + /* "View.MemoryView":441 + * return None + * + * return obj # <<<<<<<<<<<<<< + * + * cdef setitem_slice_assignment(self, dst, src): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_obj); + __pyx_r = __pyx_v_obj; + goto __pyx_L0; + + /* "View.MemoryView":433 + * self.setitem_indexed(index, value) + * + * cdef is_slice(self, obj): # <<<<<<<<<<<<<< + * if not isinstance(obj, memoryview): + * try: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_obj); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":443 + * return obj + * + * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice dst_slice + * cdef __Pyx_memviewslice src_slice + */ + +static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src) { + __Pyx_memviewslice __pyx_v_dst_slice; + __Pyx_memviewslice __pyx_v_src_slice; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + __Pyx_memviewslice *__pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setitem_slice_assignment", 0); + + /* "View.MemoryView":447 + * cdef __Pyx_memviewslice src_slice + * + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<< + * get_slice_from_memview(dst, &dst_slice)[0], + * src.ndim, dst.ndim, self.dtype_is_object) + */ + if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_memoryview_type))))) __PYX_ERR(1, 447, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_src), (&__pyx_v_src_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 447, __pyx_L1_error) + + /* "View.MemoryView":448 + * + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], + * get_slice_from_memview(dst, &dst_slice)[0], # <<<<<<<<<<<<<< + * src.ndim, dst.ndim, self.dtype_is_object) + * + */ + if (!(likely(((__pyx_v_dst) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_dst, __pyx_memoryview_type))))) __PYX_ERR(1, 448, __pyx_L1_error) + __pyx_t_2 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_2 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 448, __pyx_L1_error) + + /* "View.MemoryView":449 + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], + * get_slice_from_memview(dst, &dst_slice)[0], + * src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<< + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 449, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 449, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":447 + * cdef __Pyx_memviewslice src_slice + * + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<< + * get_slice_from_memview(dst, &dst_slice)[0], + * src.ndim, dst.ndim, self.dtype_is_object) + */ + __pyx_t_6 = __pyx_memoryview_copy_contents((__pyx_t_1[0]), (__pyx_t_2[0]), __pyx_t_4, __pyx_t_5, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 447, __pyx_L1_error) + + /* "View.MemoryView":443 + * return obj + * + * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice dst_slice + * cdef __Pyx_memviewslice src_slice + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assignment", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":451 + * src.ndim, dst.ndim, self.dtype_is_object) + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< + * cdef int array[128] + * cdef void *tmp = NULL + */ + +static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value) { + int __pyx_v_array[0x80]; + void *__pyx_v_tmp; + void *__pyx_v_item; + __Pyx_memviewslice *__pyx_v_dst_slice; + __Pyx_memviewslice __pyx_v_tmp_slice; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + char const *__pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 0); + + /* "View.MemoryView":453 + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): + * cdef int array[128] + * cdef void *tmp = NULL # <<<<<<<<<<<<<< + * cdef void *item + * + */ + __pyx_v_tmp = NULL; + + /* "View.MemoryView":458 + * cdef __Pyx_memviewslice *dst_slice + * cdef __Pyx_memviewslice tmp_slice + * dst_slice = get_slice_from_memview(dst, &tmp_slice) # <<<<<<<<<<<<<< + * + * if self.view.itemsize > sizeof(array): + */ + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 458, __pyx_L1_error) + __pyx_v_dst_slice = __pyx_t_1; + + /* "View.MemoryView":460 + * dst_slice = get_slice_from_memview(dst, &tmp_slice) + * + * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: + */ + __pyx_t_2 = ((((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array))) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":461 + * + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) # <<<<<<<<<<<<<< + * if tmp == NULL: + * raise MemoryError + */ + __pyx_v_tmp = PyMem_Malloc(__pyx_v_self->view.itemsize); + + /* "View.MemoryView":462 + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * item = tmp + */ + __pyx_t_2 = ((__pyx_v_tmp == NULL) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":463 + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * item = tmp + * else: + */ + PyErr_NoMemory(); __PYX_ERR(1, 463, __pyx_L1_error) + + /* "View.MemoryView":462 + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * item = tmp + */ + } + + /* "View.MemoryView":464 + * if tmp == NULL: + * raise MemoryError + * item = tmp # <<<<<<<<<<<<<< + * else: + * item = array + */ + __pyx_v_item = __pyx_v_tmp; + + /* "View.MemoryView":460 + * dst_slice = get_slice_from_memview(dst, &tmp_slice) + * + * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":466 + * item = tmp + * else: + * item = array # <<<<<<<<<<<<<< + * + * try: + */ + /*else*/ { + __pyx_v_item = ((void *)__pyx_v_array); + } + __pyx_L3:; + + /* "View.MemoryView":468 + * item = array + * + * try: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * ( item)[0] = value + */ + /*try:*/ { + + /* "View.MemoryView":469 + * + * try: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * ( item)[0] = value + * else: + */ + __pyx_t_2 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":470 + * try: + * if self.dtype_is_object: + * ( item)[0] = value # <<<<<<<<<<<<<< + * else: + * self.assign_item_from_object( item, value) + */ + (((PyObject **)__pyx_v_item)[0]) = ((PyObject *)__pyx_v_value); + + /* "View.MemoryView":469 + * + * try: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * ( item)[0] = value + * else: + */ + goto __pyx_L8; + } + + /* "View.MemoryView":472 + * ( item)[0] = value + * else: + * self.assign_item_from_object( item, value) # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, ((char *)__pyx_v_item), __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 472, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L8:; + + /* "View.MemoryView":476 + * + * + * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, + */ + __pyx_t_2 = ((__pyx_v_self->view.suboffsets != NULL) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":477 + * + * if self.view.suboffsets != NULL: + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) # <<<<<<<<<<<<<< + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, + * item, self.dtype_is_object) + */ + __pyx_t_3 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 477, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":476 + * + * + * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, + */ + } + + /* "View.MemoryView":478 + * if self.view.suboffsets != NULL: + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, # <<<<<<<<<<<<<< + * item, self.dtype_is_object) + * finally: + */ + __pyx_memoryview_slice_assign_scalar(__pyx_v_dst_slice, __pyx_v_dst->view.ndim, __pyx_v_self->view.itemsize, __pyx_v_item, __pyx_v_self->dtype_is_object); + } + + /* "View.MemoryView":481 + * item, self.dtype_is_object) + * finally: + * PyMem_Free(tmp) # <<<<<<<<<<<<<< + * + * cdef setitem_indexed(self, index, value): + */ + /*finally:*/ { + /*normal exit:*/{ + PyMem_Free(__pyx_v_tmp); + goto __pyx_L7; + } + __pyx_L6_error:; + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename; + { + PyMem_Free(__pyx_v_tmp); + } + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + } + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ErrRestore(__pyx_t_7, __pyx_t_8, __pyx_t_9); + __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; + __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_6; + goto __pyx_L1_error; + } + __pyx_L7:; + } + + /* "View.MemoryView":451 + * src.ndim, dst.ndim, self.dtype_is_object) + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< + * cdef int array[128] + * cdef void *tmp = NULL + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":483 + * PyMem_Free(tmp) + * + * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< + * cdef char *itemp = self.get_item_pointer(index) + * self.assign_item_from_object(itemp, value) + */ + +static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + char *__pyx_v_itemp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setitem_indexed", 0); + + /* "View.MemoryView":484 + * + * cdef setitem_indexed(self, index, value): + * cdef char *itemp = self.get_item_pointer(index) # <<<<<<<<<<<<<< + * self.assign_item_from_object(itemp, value) + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_index); if (unlikely(__pyx_t_1 == ((char *)NULL))) __PYX_ERR(1, 484, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_1; + + /* "View.MemoryView":485 + * cdef setitem_indexed(self, index, value): + * cdef char *itemp = self.get_item_pointer(index) + * self.assign_item_from_object(itemp, value) # <<<<<<<<<<<<<< + * + * cdef convert_item_to_object(self, char *itemp): + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 485, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":483 + * PyMem_Free(tmp) + * + * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< + * cdef char *itemp = self.get_item_pointer(index) + * self.assign_item_from_object(itemp, value) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_indexed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":487 + * self.assign_item_from_object(itemp, value) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + */ + +static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp) { + PyObject *__pyx_v_struct = NULL; + PyObject *__pyx_v_bytesitem = 0; + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; + int __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("convert_item_to_object", 0); + + /* "View.MemoryView":490 + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + * import struct # <<<<<<<<<<<<<< + * cdef bytes bytesitem + * + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_struct = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":493 + * cdef bytes bytesitem + * + * bytesitem = itemp[:self.view.itemsize] # <<<<<<<<<<<<<< + * try: + * result = struct.unpack(self.view.format, bytesitem) + */ + __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_itemp + 0, __pyx_v_self->view.itemsize - 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_bytesitem = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":494 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + /*try:*/ { + + /* "View.MemoryView":495 + * bytesitem = itemp[:self.view.itemsize] + * try: + * result = struct.unpack(self.view.format, bytesitem) # <<<<<<<<<<<<<< + * except struct.error: + * raise ValueError("Unable to convert item to object") + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_unpack); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6); + __Pyx_INCREF(__pyx_v_bytesitem); + __Pyx_GIVEREF(__pyx_v_bytesitem); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_bytesitem); + __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":494 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + */ + } + + /* "View.MemoryView":499 + * raise ValueError("Unable to convert item to object") + * else: + * if len(self.view.format) == 1: # <<<<<<<<<<<<<< + * return result[0] + * return result + */ + /*else:*/ { + __pyx_t_10 = strlen(__pyx_v_self->view.format); + __pyx_t_11 = ((__pyx_t_10 == 1) != 0); + if (__pyx_t_11) { + + /* "View.MemoryView":500 + * else: + * if len(self.view.format) == 1: + * return result[0] # <<<<<<<<<<<<<< + * return result + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_result, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 500, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L6_except_return; + + /* "View.MemoryView":499 + * raise ValueError("Unable to convert item to object") + * else: + * if len(self.view.format) == 1: # <<<<<<<<<<<<<< + * return result[0] + * return result + */ + } + + /* "View.MemoryView":501 + * if len(self.view.format) == 1: + * return result[0] + * return result # <<<<<<<<<<<<<< + * + * cdef assign_item_from_object(self, char *itemp, object value): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L6_except_return; + } + __pyx_L3_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "View.MemoryView":496 + * try: + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: # <<<<<<<<<<<<<< + * raise ValueError("Unable to convert item to object") + * else: + */ + __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_5, &__pyx_t_9); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 496, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_9); + __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_9 = 0; + if (__pyx_t_8) { + __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 496, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_1); + + /* "View.MemoryView":497 + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< + * else: + * if len(self.view.format) == 1: + */ + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 497, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(1, 497, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "View.MemoryView":494 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + */ + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L1_error; + __pyx_L6_except_return:; + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L0; + } + + /* "View.MemoryView":487 + * self.assign_item_from_object(itemp, value) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_struct); + __Pyx_XDECREF(__pyx_v_bytesitem); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":503 + * return result + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + */ + +static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { + PyObject *__pyx_v_struct = NULL; + char __pyx_v_c; + PyObject *__pyx_v_bytesvalue = 0; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + Py_ssize_t __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + char *__pyx_t_11; + char *__pyx_t_12; + char *__pyx_t_13; + char *__pyx_t_14; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("assign_item_from_object", 0); + + /* "View.MemoryView":506 + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + * import struct # <<<<<<<<<<<<<< + * cdef char c + * cdef bytes bytesvalue + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 506, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_struct = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":511 + * cdef Py_ssize_t i + * + * if isinstance(value, tuple): # <<<<<<<<<<<<<< + * bytesvalue = struct.pack(self.view.format, *value) + * else: + */ + __pyx_t_2 = PyTuple_Check(__pyx_v_value); + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "View.MemoryView":512 + * + * if isinstance(value, tuple): + * bytesvalue = struct.pack(self.view.format, *value) # <<<<<<<<<<<<<< + * else: + * bytesvalue = struct.pack(self.view.format, value) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||((void)PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 512, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":511 + * cdef Py_ssize_t i + * + * if isinstance(value, tuple): # <<<<<<<<<<<<<< + * bytesvalue = struct.pack(self.view.format, *value) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":514 + * bytesvalue = struct.pack(self.view.format, *value) + * else: + * bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<< + * + * for i, c in enumerate(bytesvalue): + */ + /*else*/ { + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_value); + __pyx_t_1 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||((void)PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 514, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + } + __pyx_L3:; + + /* "View.MemoryView":516 + * bytesvalue = struct.pack(self.view.format, value) + * + * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< + * itemp[i] = c + * + */ + __pyx_t_9 = 0; + if (unlikely(__pyx_v_bytesvalue == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable"); + __PYX_ERR(1, 516, __pyx_L1_error) + } + __Pyx_INCREF(__pyx_v_bytesvalue); + __pyx_t_10 = __pyx_v_bytesvalue; + __pyx_t_12 = PyBytes_AS_STRING(__pyx_t_10); + __pyx_t_13 = (__pyx_t_12 + PyBytes_GET_SIZE(__pyx_t_10)); + for (__pyx_t_14 = __pyx_t_12; __pyx_t_14 < __pyx_t_13; __pyx_t_14++) { + __pyx_t_11 = __pyx_t_14; + __pyx_v_c = (__pyx_t_11[0]); + + /* "View.MemoryView":517 + * + * for i, c in enumerate(bytesvalue): + * itemp[i] = c # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + __pyx_v_i = __pyx_t_9; + + /* "View.MemoryView":516 + * bytesvalue = struct.pack(self.view.format, value) + * + * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< + * itemp[i] = c + * + */ + __pyx_t_9 = (__pyx_t_9 + 1); + + /* "View.MemoryView":517 + * + * for i, c in enumerate(bytesvalue): + * itemp[i] = c # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c; + } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "View.MemoryView":503 + * return result + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("View.MemoryView.memoryview.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_struct); + __Pyx_XDECREF(__pyx_v_bytesvalue); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":520 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError("Cannot create writable memory view from read-only memoryview") + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t *__pyx_t_4; + char *__pyx_t_5; + void *__pyx_t_6; + int __pyx_t_7; + Py_ssize_t __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + if (__pyx_v_info == NULL) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + + /* "View.MemoryView":521 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + */ + __pyx_t_2 = ((__pyx_v_flags & PyBUF_WRITABLE) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_self->view.readonly != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":522 + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<< + * + * if flags & PyBUF_ND: + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 522, __pyx_L1_error) + + /* "View.MemoryView":521 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + */ + } + + /* "View.MemoryView":524 + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + * if flags & PyBUF_ND: # <<<<<<<<<<<<<< + * info.shape = self.view.shape + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":525 + * + * if flags & PyBUF_ND: + * info.shape = self.view.shape # <<<<<<<<<<<<<< + * else: + * info.shape = NULL + */ + __pyx_t_4 = __pyx_v_self->view.shape; + __pyx_v_info->shape = __pyx_t_4; + + /* "View.MemoryView":524 + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + * if flags & PyBUF_ND: # <<<<<<<<<<<<<< + * info.shape = self.view.shape + * else: + */ + goto __pyx_L6; + } + + /* "View.MemoryView":527 + * info.shape = self.view.shape + * else: + * info.shape = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_STRIDES: + */ + /*else*/ { + __pyx_v_info->shape = NULL; + } + __pyx_L6:; + + /* "View.MemoryView":529 + * info.shape = NULL + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.strides = self.view.strides + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":530 + * + * if flags & PyBUF_STRIDES: + * info.strides = self.view.strides # <<<<<<<<<<<<<< + * else: + * info.strides = NULL + */ + __pyx_t_4 = __pyx_v_self->view.strides; + __pyx_v_info->strides = __pyx_t_4; + + /* "View.MemoryView":529 + * info.shape = NULL + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.strides = self.view.strides + * else: + */ + goto __pyx_L7; + } + + /* "View.MemoryView":532 + * info.strides = self.view.strides + * else: + * info.strides = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_INDIRECT: + */ + /*else*/ { + __pyx_v_info->strides = NULL; + } + __pyx_L7:; + + /* "View.MemoryView":534 + * info.strides = NULL + * + * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< + * info.suboffsets = self.view.suboffsets + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_INDIRECT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":535 + * + * if flags & PyBUF_INDIRECT: + * info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<< + * else: + * info.suboffsets = NULL + */ + __pyx_t_4 = __pyx_v_self->view.suboffsets; + __pyx_v_info->suboffsets = __pyx_t_4; + + /* "View.MemoryView":534 + * info.strides = NULL + * + * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< + * info.suboffsets = self.view.suboffsets + * else: + */ + goto __pyx_L8; + } + + /* "View.MemoryView":537 + * info.suboffsets = self.view.suboffsets + * else: + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + /*else*/ { + __pyx_v_info->suboffsets = NULL; + } + __pyx_L8:; + + /* "View.MemoryView":539 + * info.suboffsets = NULL + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.view.format + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":540 + * + * if flags & PyBUF_FORMAT: + * info.format = self.view.format # <<<<<<<<<<<<<< + * else: + * info.format = NULL + */ + __pyx_t_5 = __pyx_v_self->view.format; + __pyx_v_info->format = __pyx_t_5; + + /* "View.MemoryView":539 + * info.suboffsets = NULL + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.view.format + * else: + */ + goto __pyx_L9; + } + + /* "View.MemoryView":542 + * info.format = self.view.format + * else: + * info.format = NULL # <<<<<<<<<<<<<< + * + * info.buf = self.view.buf + */ + /*else*/ { + __pyx_v_info->format = NULL; + } + __pyx_L9:; + + /* "View.MemoryView":544 + * info.format = NULL + * + * info.buf = self.view.buf # <<<<<<<<<<<<<< + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize + */ + __pyx_t_6 = __pyx_v_self->view.buf; + __pyx_v_info->buf = __pyx_t_6; + + /* "View.MemoryView":545 + * + * info.buf = self.view.buf + * info.ndim = self.view.ndim # <<<<<<<<<<<<<< + * info.itemsize = self.view.itemsize + * info.len = self.view.len + */ + __pyx_t_7 = __pyx_v_self->view.ndim; + __pyx_v_info->ndim = __pyx_t_7; + + /* "View.MemoryView":546 + * info.buf = self.view.buf + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize # <<<<<<<<<<<<<< + * info.len = self.view.len + * info.readonly = self.view.readonly + */ + __pyx_t_8 = __pyx_v_self->view.itemsize; + __pyx_v_info->itemsize = __pyx_t_8; + + /* "View.MemoryView":547 + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize + * info.len = self.view.len # <<<<<<<<<<<<<< + * info.readonly = self.view.readonly + * info.obj = self + */ + __pyx_t_8 = __pyx_v_self->view.len; + __pyx_v_info->len = __pyx_t_8; + + /* "View.MemoryView":548 + * info.itemsize = self.view.itemsize + * info.len = self.view.len + * info.readonly = self.view.readonly # <<<<<<<<<<<<<< + * info.obj = self + * + */ + __pyx_t_1 = __pyx_v_self->view.readonly; + __pyx_v_info->readonly = __pyx_t_1; + + /* "View.MemoryView":549 + * info.len = self.view.len + * info.readonly = self.view.readonly + * info.obj = self # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") + */ + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + + /* "View.MemoryView":520 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError("Cannot create writable memory view from read-only memoryview") + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":555 + * + * @property + * def T(self): # <<<<<<<<<<<<<< + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":556 + * @property + * def T(self): + * cdef _memoryviewslice result = memoryview_copy(self) # <<<<<<<<<<<<<< + * transpose_memslice(&result.from_slice) + * return result + */ + __pyx_t_1 = __pyx_memoryview_copy_object(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 556, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_memoryviewslice_type))))) __PYX_ERR(1, 556, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":557 + * def T(self): + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_2 = __pyx_memslice_transpose((&__pyx_v_result->from_slice)); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 557, __pyx_L1_error) + + /* "View.MemoryView":558 + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) + * return result # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "View.MemoryView":555 + * + * @property + * def T(self): # <<<<<<<<<<<<<< + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.T.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":561 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.obj + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":562 + * @property + * def base(self): + * return self.obj # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->obj); + __pyx_r = __pyx_v_self->obj; + goto __pyx_L0; + + /* "View.MemoryView":561 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.obj + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":565 + * + * @property + * def shape(self): # <<<<<<<<<<<<<< + * return tuple([length for length in self.view.shape[:self.view.ndim]]) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_v_length; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":566 + * @property + * def shape(self): + * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); + for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { + __pyx_t_2 = __pyx_t_4; + __pyx_v_length = (__pyx_t_2[0]); + __pyx_t_5 = PyInt_FromSsize_t(__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "View.MemoryView":565 + * + * @property + * def shape(self): # <<<<<<<<<<<<<< + * return tuple([length for length in self.view.shape[:self.view.ndim]]) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.shape.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":569 + * + * @property + * def strides(self): # <<<<<<<<<<<<<< + * if self.view.strides == NULL: + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_v_stride; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":570 + * @property + * def strides(self): + * if self.view.strides == NULL: # <<<<<<<<<<<<<< + * + * raise ValueError("Buffer view does not expose strides") + */ + __pyx_t_1 = ((__pyx_v_self->view.strides == NULL) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":572 + * if self.view.strides == NULL: + * + * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 572, __pyx_L1_error) + + /* "View.MemoryView":570 + * @property + * def strides(self): + * if self.view.strides == NULL: # <<<<<<<<<<<<<< + * + * raise ValueError("Buffer view does not expose strides") + */ + } + + /* "View.MemoryView":574 + * raise ValueError("Buffer view does not expose strides") + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = (__pyx_v_self->view.strides + __pyx_v_self->view.ndim); + for (__pyx_t_5 = __pyx_v_self->view.strides; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { + __pyx_t_3 = __pyx_t_5; + __pyx_v_stride = (__pyx_t_3[0]); + __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; + goto __pyx_L0; + + /* "View.MemoryView":569 + * + * @property + * def strides(self): # <<<<<<<<<<<<<< + * if self.view.strides == NULL: + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView.memoryview.strides.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":577 + * + * @property + * def suboffsets(self): # <<<<<<<<<<<<<< + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_v_suboffset; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + Py_ssize_t *__pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":578 + * @property + * def suboffsets(self): + * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< + * return (-1,) * self.view.ndim + * + */ + __pyx_t_1 = ((__pyx_v_self->view.suboffsets == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":579 + * def suboffsets(self): + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_tuple__12, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":578 + * @property + * def suboffsets(self): + * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< + * return (-1,) * self.view.ndim + * + */ + } + + /* "View.MemoryView":581 + * return (-1,) * self.view.ndim + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim); + for (__pyx_t_6 = __pyx_v_self->view.suboffsets; __pyx_t_6 < __pyx_t_5; __pyx_t_6++) { + __pyx_t_4 = __pyx_t_6; + __pyx_v_suboffset = (__pyx_t_4[0]); + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_suboffset); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_2))) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = PyList_AsTuple(((PyObject*)__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":577 + * + * @property + * def suboffsets(self): # <<<<<<<<<<<<<< + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.suboffsets.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":584 + * + * @property + * def ndim(self): # <<<<<<<<<<<<<< + * return self.view.ndim + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":585 + * @property + * def ndim(self): + * return self.view.ndim # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 585, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":584 + * + * @property + * def ndim(self): # <<<<<<<<<<<<<< + * return self.view.ndim + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.ndim.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":588 + * + * @property + * def itemsize(self): # <<<<<<<<<<<<<< + * return self.view.itemsize + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":589 + * @property + * def itemsize(self): + * return self.view.itemsize # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":588 + * + * @property + * def itemsize(self): # <<<<<<<<<<<<<< + * return self.view.itemsize + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.itemsize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":592 + * + * @property + * def nbytes(self): # <<<<<<<<<<<<<< + * return self.size * self.view.itemsize + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":593 + * @property + * def nbytes(self): + * return self.size * self.view.itemsize # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":592 + * + * @property + * def nbytes(self): # <<<<<<<<<<<<<< + * return self.size * self.view.itemsize + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.nbytes.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":596 + * + * @property + * def size(self): # <<<<<<<<<<<<<< + * if self._size is None: + * result = 1 + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_v_length = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":597 + * @property + * def size(self): + * if self._size is None: # <<<<<<<<<<<<<< + * result = 1 + * + */ + __pyx_t_1 = (__pyx_v_self->_size == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":598 + * def size(self): + * if self._size is None: + * result = 1 # <<<<<<<<<<<<<< + * + * for length in self.view.shape[:self.view.ndim]: + */ + __Pyx_INCREF(__pyx_int_1); + __pyx_v_result = __pyx_int_1; + + /* "View.MemoryView":600 + * result = 1 + * + * for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<< + * result *= length + * + */ + __pyx_t_4 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); + for (__pyx_t_5 = __pyx_v_self->view.shape; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { + __pyx_t_3 = __pyx_t_5; + __pyx_t_6 = PyInt_FromSsize_t((__pyx_t_3[0])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_6); + __pyx_t_6 = 0; + + /* "View.MemoryView":601 + * + * for length in self.view.shape[:self.view.ndim]: + * result *= length # <<<<<<<<<<<<<< + * + * self._size = result + */ + __pyx_t_6 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_6); + __pyx_t_6 = 0; + } + + /* "View.MemoryView":603 + * result *= length + * + * self._size = result # <<<<<<<<<<<<<< + * + * return self._size + */ + __Pyx_INCREF(__pyx_v_result); + __Pyx_GIVEREF(__pyx_v_result); + __Pyx_GOTREF(__pyx_v_self->_size); + __Pyx_DECREF(__pyx_v_self->_size); + __pyx_v_self->_size = __pyx_v_result; + + /* "View.MemoryView":597 + * @property + * def size(self): + * if self._size is None: # <<<<<<<<<<<<<< + * result = 1 + * + */ + } + + /* "View.MemoryView":605 + * self._size = result + * + * return self._size # <<<<<<<<<<<<<< + * + * def __len__(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_size); + __pyx_r = __pyx_v_self->_size; + goto __pyx_L0; + + /* "View.MemoryView":596 + * + * @property + * def size(self): # <<<<<<<<<<<<<< + * if self._size is None: + * result = 1 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView.memoryview.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_length); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":607 + * return self._size + * + * def __len__(self): # <<<<<<<<<<<<<< + * if self.view.ndim >= 1: + * return self.view.shape[0] + */ + +/* Python wrapper */ +static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self); /*proto*/ +static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__len__", 0); + + /* "View.MemoryView":608 + * + * def __len__(self): + * if self.view.ndim >= 1: # <<<<<<<<<<<<<< + * return self.view.shape[0] + * + */ + __pyx_t_1 = ((__pyx_v_self->view.ndim >= 1) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":609 + * def __len__(self): + * if self.view.ndim >= 1: + * return self.view.shape[0] # <<<<<<<<<<<<<< + * + * return 0 + */ + __pyx_r = (__pyx_v_self->view.shape[0]); + goto __pyx_L0; + + /* "View.MemoryView":608 + * + * def __len__(self): + * if self.view.ndim >= 1: # <<<<<<<<<<<<<< + * return self.view.shape[0] + * + */ + } + + /* "View.MemoryView":611 + * return self.view.shape[0] + * + * return 0 # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":607 + * return self._size + * + * def __len__(self): # <<<<<<<<<<<<<< + * if self.view.ndim >= 1: + * return self.view.shape[0] + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":613 + * return 0 + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__, + * id(self)) + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "View.MemoryView":614 + * + * def __repr__(self): + * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< + * id(self)) + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":615 + * def __repr__(self): + * return "" % (self.base.__class__.__name__, + * id(self)) # <<<<<<<<<<<<<< + * + * def __str__(self): + */ + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "View.MemoryView":614 + * + * def __repr__(self): + * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< + * id(self)) + * + */ + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":613 + * return 0 + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__, + * id(self)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":617 + * id(self)) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__,) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__str__", 0); + + /* "View.MemoryView":618 + * + * def __str__(self): + * return "" % (self.base.__class__.__name__,) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_object, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":617 + * id(self)) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__,) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":621 + * + * + * def is_c_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_c_contig (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice *__pyx_v_mslice; + __Pyx_memviewslice __pyx_v_tmp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_c_contig", 0); + + /* "View.MemoryView":624 + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< + * return slice_is_contig(mslice[0], 'C', self.view.ndim) + * + */ + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 624, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":625 + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) + * return slice_is_contig(mslice[0], 'C', self.view.ndim) # <<<<<<<<<<<<<< + * + * def is_f_contig(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'C', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":621 + * + * + * def is_c_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.is_c_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":627 + * return slice_is_contig(mslice[0], 'C', self.view.ndim) + * + * def is_f_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_f_contig (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice *__pyx_v_mslice; + __Pyx_memviewslice __pyx_v_tmp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_f_contig", 0); + + /* "View.MemoryView":630 + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< + * return slice_is_contig(mslice[0], 'F', self.view.ndim) + * + */ + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 630, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":631 + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) + * return slice_is_contig(mslice[0], 'F', self.view.ndim) # <<<<<<<<<<<<<< + * + * def copy(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'F', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":627 + * return slice_is_contig(mslice[0], 'C', self.view.ndim) + * + * def is_f_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.is_f_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":633 + * return slice_is_contig(mslice[0], 'F', self.view.ndim) + * + * def copy(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice mslice + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice __pyx_v_mslice; + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("copy", 0); + + /* "View.MemoryView":635 + * def copy(self): + * cdef __Pyx_memviewslice mslice + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS # <<<<<<<<<<<<<< + * + * slice_copy(self, &mslice) + */ + __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_F_CONTIGUOUS)); + + /* "View.MemoryView":637 + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS + * + * slice_copy(self, &mslice) # <<<<<<<<<<<<<< + * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, + * self.view.itemsize, + */ + __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_mslice)); + + /* "View.MemoryView":638 + * + * slice_copy(self, &mslice) + * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, # <<<<<<<<<<<<<< + * self.view.itemsize, + * flags|PyBUF_C_CONTIGUOUS, + */ + __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_mslice), ((char *)"c"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_C_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 638, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":643 + * self.dtype_is_object) + * + * return memoryview_copy_from_slice(self, &mslice) # <<<<<<<<<<<<<< + * + * def copy_fortran(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_mslice)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 643, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":633 + * return slice_is_contig(mslice[0], 'F', self.view.ndim) + * + * def copy(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice mslice + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":645 + * return memoryview_copy_from_slice(self, &mslice) + * + * def copy_fortran(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice src, dst + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy_fortran (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice __pyx_v_src; + __Pyx_memviewslice __pyx_v_dst; + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("copy_fortran", 0); + + /* "View.MemoryView":647 + * def copy_fortran(self): + * cdef __Pyx_memviewslice src, dst + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS # <<<<<<<<<<<<<< + * + * slice_copy(self, &src) + */ + __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_C_CONTIGUOUS)); + + /* "View.MemoryView":649 + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS + * + * slice_copy(self, &src) # <<<<<<<<<<<<<< + * dst = slice_copy_contig(&src, "fortran", self.view.ndim, + * self.view.itemsize, + */ + __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_src)); + + /* "View.MemoryView":650 + * + * slice_copy(self, &src) + * dst = slice_copy_contig(&src, "fortran", self.view.ndim, # <<<<<<<<<<<<<< + * self.view.itemsize, + * flags|PyBUF_F_CONTIGUOUS, + */ + __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_src), ((char *)"fortran"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_F_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 650, __pyx_L1_error) + __pyx_v_dst = __pyx_t_1; + + /* "View.MemoryView":655 + * self.dtype_is_object) + * + * return memoryview_copy_from_slice(self, &dst) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_dst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 655, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":645 + * return memoryview_copy_from_slice(self, &mslice) + * + * def copy_fortran(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice src, dst + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.copy_fortran", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_memoryview___reduce_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__13, 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__14, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":659 + * + * @cname('__pyx_memoryview_new') + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo + */ + +static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, int __pyx_v_dtype_is_object, __Pyx_TypeInfo *__pyx_v_typeinfo) { + struct __pyx_memoryview_obj *__pyx_v_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_cwrapper", 0); + + /* "View.MemoryView":660 + * @cname('__pyx_memoryview_new') + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): + * cdef memoryview result = memoryview(o, flags, dtype_is_object) # <<<<<<<<<<<<<< + * result.typeinfo = typeinfo + * return result + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_o); + __Pyx_GIVEREF(__pyx_v_o); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_o); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = ((struct __pyx_memoryview_obj *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":661 + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_v_result->typeinfo = __pyx_v_typeinfo; + + /* "View.MemoryView":662 + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo + * return result # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_check') + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "View.MemoryView":659 + * + * @cname('__pyx_memoryview_new') + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":665 + * + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< + * return isinstance(o, memoryview) + * + */ + +static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("memoryview_check", 0); + + /* "View.MemoryView":666 + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): + * return isinstance(o, memoryview) # <<<<<<<<<<<<<< + * + * cdef tuple _unellipsify(object index, int ndim): + */ + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_o, __pyx_memoryview_type); + __pyx_r = __pyx_t_1; + goto __pyx_L0; + + /* "View.MemoryView":665 + * + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< + * return isinstance(o, memoryview) + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":668 + * return isinstance(o, memoryview) + * + * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< + * """ + * Replace all ellipses with full slices and fill incomplete indices with + */ + +static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { + PyObject *__pyx_v_tup = NULL; + PyObject *__pyx_v_result = NULL; + int __pyx_v_have_slices; + int __pyx_v_seen_ellipsis; + CYTHON_UNUSED PyObject *__pyx_v_idx = NULL; + PyObject *__pyx_v_item = NULL; + Py_ssize_t __pyx_v_nslices; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + PyObject *__pyx_t_7 = NULL; + Py_ssize_t __pyx_t_8; + int __pyx_t_9; + int __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_unellipsify", 0); + + /* "View.MemoryView":673 + * full slices. + * """ + * if not isinstance(index, tuple): # <<<<<<<<<<<<<< + * tup = (index,) + * else: + */ + __pyx_t_1 = PyTuple_Check(__pyx_v_index); + __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":674 + * """ + * if not isinstance(index, tuple): + * tup = (index,) # <<<<<<<<<<<<<< + * else: + * tup = index + */ + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 674, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_index); + __Pyx_GIVEREF(__pyx_v_index); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_index); + __pyx_v_tup = __pyx_t_3; + __pyx_t_3 = 0; + + /* "View.MemoryView":673 + * full slices. + * """ + * if not isinstance(index, tuple): # <<<<<<<<<<<<<< + * tup = (index,) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":676 + * tup = (index,) + * else: + * tup = index # <<<<<<<<<<<<<< + * + * result = [] + */ + /*else*/ { + __Pyx_INCREF(__pyx_v_index); + __pyx_v_tup = __pyx_v_index; + } + __pyx_L3:; + + /* "View.MemoryView":678 + * tup = index + * + * result = [] # <<<<<<<<<<<<<< + * have_slices = False + * seen_ellipsis = False + */ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 678, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_result = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":679 + * + * result = [] + * have_slices = False # <<<<<<<<<<<<<< + * seen_ellipsis = False + * for idx, item in enumerate(tup): + */ + __pyx_v_have_slices = 0; + + /* "View.MemoryView":680 + * result = [] + * have_slices = False + * seen_ellipsis = False # <<<<<<<<<<<<<< + * for idx, item in enumerate(tup): + * if item is Ellipsis: + */ + __pyx_v_seen_ellipsis = 0; + + /* "View.MemoryView":681 + * have_slices = False + * seen_ellipsis = False + * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< + * if item is Ellipsis: + * if not seen_ellipsis: + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_3 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_tup)) || PyTuple_CheckExact(__pyx_v_tup)) { + __pyx_t_4 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_tup); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 681, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_4))) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 681, __pyx_L1_error) + #else + __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } else { + if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 681, __pyx_L1_error) + #else + __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } + } else { + __pyx_t_7 = __pyx_t_6(__pyx_t_4); + if (unlikely(!__pyx_t_7)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 681, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_7); + } + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_3); + __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); + __pyx_t_3 = __pyx_t_7; + __pyx_t_7 = 0; + + /* "View.MemoryView":682 + * seen_ellipsis = False + * for idx, item in enumerate(tup): + * if item is Ellipsis: # <<<<<<<<<<<<<< + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + */ + __pyx_t_2 = (__pyx_v_item == __pyx_builtin_Ellipsis); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":683 + * for idx, item in enumerate(tup): + * if item is Ellipsis: + * if not seen_ellipsis: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True + */ + __pyx_t_1 = ((!(__pyx_v_seen_ellipsis != 0)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":684 + * if item is Ellipsis: + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<< + * seen_ellipsis = True + * else: + */ + __pyx_t_8 = PyObject_Length(__pyx_v_tup); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(1, 684, __pyx_L1_error) + __pyx_t_7 = PyList_New(1 * ((((__pyx_v_ndim - __pyx_t_8) + 1)<0) ? 0:((__pyx_v_ndim - __pyx_t_8) + 1))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 684, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < ((__pyx_v_ndim - __pyx_t_8) + 1); __pyx_temp++) { + __Pyx_INCREF(__pyx_slice__15); + __Pyx_GIVEREF(__pyx_slice__15); + PyList_SET_ITEM(__pyx_t_7, __pyx_temp, __pyx_slice__15); + } + } + __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_7); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 684, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "View.MemoryView":685 + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True # <<<<<<<<<<<<<< + * else: + * result.append(slice(None)) + */ + __pyx_v_seen_ellipsis = 1; + + /* "View.MemoryView":683 + * for idx, item in enumerate(tup): + * if item is Ellipsis: + * if not seen_ellipsis: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True + */ + goto __pyx_L7; + } + + /* "View.MemoryView":687 + * seen_ellipsis = True + * else: + * result.append(slice(None)) # <<<<<<<<<<<<<< + * have_slices = True + * else: + */ + /*else*/ { + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_slice__15); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 687, __pyx_L1_error) + } + __pyx_L7:; + + /* "View.MemoryView":688 + * else: + * result.append(slice(None)) + * have_slices = True # <<<<<<<<<<<<<< + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): + */ + __pyx_v_have_slices = 1; + + /* "View.MemoryView":682 + * seen_ellipsis = False + * for idx, item in enumerate(tup): + * if item is Ellipsis: # <<<<<<<<<<<<<< + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + */ + goto __pyx_L6; + } + + /* "View.MemoryView":690 + * have_slices = True + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + */ + /*else*/ { + __pyx_t_2 = PySlice_Check(__pyx_v_item); + __pyx_t_10 = ((!(__pyx_t_2 != 0)) != 0); + if (__pyx_t_10) { + } else { + __pyx_t_1 = __pyx_t_10; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_10 = ((!(PyIndex_Check(__pyx_v_item) != 0)) != 0); + __pyx_t_1 = __pyx_t_10; + __pyx_L9_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":691 + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): + * raise TypeError("Cannot index with type '%s'" % type(item)) # <<<<<<<<<<<<<< + * + * have_slices = have_slices or isinstance(item, slice) + */ + __pyx_t_7 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Cannot_index_with_type_s, ((PyObject *)Py_TYPE(__pyx_v_item))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_11, 0, 0, 0); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __PYX_ERR(1, 691, __pyx_L1_error) + + /* "View.MemoryView":690 + * have_slices = True + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + */ + } + + /* "View.MemoryView":693 + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + * have_slices = have_slices or isinstance(item, slice) # <<<<<<<<<<<<<< + * result.append(item) + * + */ + __pyx_t_10 = (__pyx_v_have_slices != 0); + if (!__pyx_t_10) { + } else { + __pyx_t_1 = __pyx_t_10; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_10 = PySlice_Check(__pyx_v_item); + __pyx_t_2 = (__pyx_t_10 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L11_bool_binop_done:; + __pyx_v_have_slices = __pyx_t_1; + + /* "View.MemoryView":694 + * + * have_slices = have_slices or isinstance(item, slice) + * result.append(item) # <<<<<<<<<<<<<< + * + * nslices = ndim - len(result) + */ + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_v_item); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 694, __pyx_L1_error) + } + __pyx_L6:; + + /* "View.MemoryView":681 + * have_slices = False + * seen_ellipsis = False + * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< + * if item is Ellipsis: + * if not seen_ellipsis: + */ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":696 + * result.append(item) + * + * nslices = ndim - len(result) # <<<<<<<<<<<<<< + * if nslices: + * result.extend([slice(None)] * nslices) + */ + __pyx_t_5 = PyList_GET_SIZE(__pyx_v_result); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 696, __pyx_L1_error) + __pyx_v_nslices = (__pyx_v_ndim - __pyx_t_5); + + /* "View.MemoryView":697 + * + * nslices = ndim - len(result) + * if nslices: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * nslices) + * + */ + __pyx_t_1 = (__pyx_v_nslices != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":698 + * nslices = ndim - len(result) + * if nslices: + * result.extend([slice(None)] * nslices) # <<<<<<<<<<<<<< + * + * return have_slices or nslices, tuple(result) + */ + __pyx_t_3 = PyList_New(1 * ((__pyx_v_nslices<0) ? 0:__pyx_v_nslices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 698, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < __pyx_v_nslices; __pyx_temp++) { + __Pyx_INCREF(__pyx_slice__15); + __Pyx_GIVEREF(__pyx_slice__15); + PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_slice__15); + } + } + __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 698, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":697 + * + * nslices = ndim - len(result) + * if nslices: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * nslices) + * + */ + } + + /* "View.MemoryView":700 + * result.extend([slice(None)] * nslices) + * + * return have_slices or nslices, tuple(result) # <<<<<<<<<<<<<< + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + */ + __Pyx_XDECREF(__pyx_r); + if (!__pyx_v_have_slices) { + } else { + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L14_bool_binop_done; + } + __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_L14_bool_binop_done:; + __pyx_t_4 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_4); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_r = ((PyObject*)__pyx_t_11); + __pyx_t_11 = 0; + goto __pyx_L0; + + /* "View.MemoryView":668 + * return isinstance(o, memoryview) + * + * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< + * """ + * Replace all ellipses with full slices and fill incomplete indices with + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("View.MemoryView._unellipsify", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_tup); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_idx); + __Pyx_XDECREF(__pyx_v_item); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":702 + * return have_slices or nslices, tuple(result) + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + */ + +static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __pyx_v_ndim) { + Py_ssize_t __pyx_v_suboffset; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t *__pyx_t_1; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("assert_direct_dimensions", 0); + + /* "View.MemoryView":703 + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * for suboffset in suboffsets[:ndim]: # <<<<<<<<<<<<<< + * if suboffset >= 0: + * raise ValueError("Indirect dimensions not supported") + */ + __pyx_t_2 = (__pyx_v_suboffsets + __pyx_v_ndim); + for (__pyx_t_3 = __pyx_v_suboffsets; __pyx_t_3 < __pyx_t_2; __pyx_t_3++) { + __pyx_t_1 = __pyx_t_3; + __pyx_v_suboffset = (__pyx_t_1[0]); + + /* "View.MemoryView":704 + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * raise ValueError("Indirect dimensions not supported") + * + */ + __pyx_t_4 = ((__pyx_v_suboffset >= 0) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":705 + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + * raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(1, 705, __pyx_L1_error) + + /* "View.MemoryView":704 + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * raise ValueError("Indirect dimensions not supported") + * + */ + } + } + + /* "View.MemoryView":702 + * return have_slices or nslices, tuple(result) + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.assert_direct_dimensions", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":712 + * + * @cname('__pyx_memview_slice') + * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< + * cdef int new_ndim = 0, suboffset_dim = -1, dim + * cdef bint negative_step + */ + +static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *__pyx_v_memview, PyObject *__pyx_v_indices) { + int __pyx_v_new_ndim; + int __pyx_v_suboffset_dim; + int __pyx_v_dim; + __Pyx_memviewslice __pyx_v_src; + __Pyx_memviewslice __pyx_v_dst; + __Pyx_memviewslice *__pyx_v_p_src; + struct __pyx_memoryviewslice_obj *__pyx_v_memviewsliceobj = 0; + __Pyx_memviewslice *__pyx_v_p_dst; + int *__pyx_v_p_suboffset_dim; + Py_ssize_t __pyx_v_start; + Py_ssize_t __pyx_v_stop; + Py_ssize_t __pyx_v_step; + int __pyx_v_have_start; + int __pyx_v_have_stop; + int __pyx_v_have_step; + PyObject *__pyx_v_index = NULL; + struct __pyx_memoryview_obj *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + struct __pyx_memoryview_obj *__pyx_t_4; + char *__pyx_t_5; + int __pyx_t_6; + Py_ssize_t __pyx_t_7; + PyObject *(*__pyx_t_8)(PyObject *); + PyObject *__pyx_t_9 = NULL; + Py_ssize_t __pyx_t_10; + int __pyx_t_11; + Py_ssize_t __pyx_t_12; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memview_slice", 0); + + /* "View.MemoryView":713 + * @cname('__pyx_memview_slice') + * cdef memoryview memview_slice(memoryview memview, object indices): + * cdef int new_ndim = 0, suboffset_dim = -1, dim # <<<<<<<<<<<<<< + * cdef bint negative_step + * cdef __Pyx_memviewslice src, dst + */ + __pyx_v_new_ndim = 0; + __pyx_v_suboffset_dim = -1; + + /* "View.MemoryView":720 + * + * + * memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<< + * + * cdef _memoryviewslice memviewsliceobj + */ + (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst)))); + + /* "View.MemoryView":724 + * cdef _memoryviewslice memviewsliceobj + * + * assert memview.view.ndim > 0 # <<<<<<<<<<<<<< + * + * if isinstance(memview, _memoryviewslice): + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!((__pyx_v_memview->view.ndim > 0) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + __PYX_ERR(1, 724, __pyx_L1_error) + } + } + #endif + + /* "View.MemoryView":726 + * assert memview.view.ndim > 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":727 + * + * if isinstance(memview, _memoryviewslice): + * memviewsliceobj = memview # <<<<<<<<<<<<<< + * p_src = &memviewsliceobj.from_slice + * else: + */ + if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 727, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_v_memview); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":728 + * if isinstance(memview, _memoryviewslice): + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice # <<<<<<<<<<<<<< + * else: + * slice_copy(memview, &src) + */ + __pyx_v_p_src = (&__pyx_v_memviewsliceobj->from_slice); + + /* "View.MemoryView":726 + * assert memview.view.ndim > 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice + */ + goto __pyx_L3; + } + + /* "View.MemoryView":730 + * p_src = &memviewsliceobj.from_slice + * else: + * slice_copy(memview, &src) # <<<<<<<<<<<<<< + * p_src = &src + * + */ + /*else*/ { + __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_src)); + + /* "View.MemoryView":731 + * else: + * slice_copy(memview, &src) + * p_src = &src # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_p_src = (&__pyx_v_src); + } + __pyx_L3:; + + /* "View.MemoryView":737 + * + * + * dst.memview = p_src.memview # <<<<<<<<<<<<<< + * dst.data = p_src.data + * + */ + __pyx_t_4 = __pyx_v_p_src->memview; + __pyx_v_dst.memview = __pyx_t_4; + + /* "View.MemoryView":738 + * + * dst.memview = p_src.memview + * dst.data = p_src.data # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __pyx_v_p_src->data; + __pyx_v_dst.data = __pyx_t_5; + + /* "View.MemoryView":743 + * + * + * cdef __Pyx_memviewslice *p_dst = &dst # <<<<<<<<<<<<<< + * cdef int *p_suboffset_dim = &suboffset_dim + * cdef Py_ssize_t start, stop, step + */ + __pyx_v_p_dst = (&__pyx_v_dst); + + /* "View.MemoryView":744 + * + * cdef __Pyx_memviewslice *p_dst = &dst + * cdef int *p_suboffset_dim = &suboffset_dim # <<<<<<<<<<<<<< + * cdef Py_ssize_t start, stop, step + * cdef bint have_start, have_stop, have_step + */ + __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim); + + /* "View.MemoryView":748 + * cdef bint have_start, have_stop, have_step + * + * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< + * if PyIndex_Check(index): + * slice_memviewslice( + */ + __pyx_t_6 = 0; + if (likely(PyList_CheckExact(__pyx_v_indices)) || PyTuple_CheckExact(__pyx_v_indices)) { + __pyx_t_3 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_3); __pyx_t_7 = 0; + __pyx_t_8 = NULL; + } else { + __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 748, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_8)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_9 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(1, 748, __pyx_L1_error) + #else + __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + } else { + if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(1, 748, __pyx_L1_error) + #else + __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + } + } else { + __pyx_t_9 = __pyx_t_8(__pyx_t_3); + if (unlikely(!__pyx_t_9)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 748, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_9); + } + __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_v_dim = __pyx_t_6; + __pyx_t_6 = (__pyx_t_6 + 1); + + /* "View.MemoryView":749 + * + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): # <<<<<<<<<<<<<< + * slice_memviewslice( + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + */ + __pyx_t_2 = (PyIndex_Check(__pyx_v_index) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":753 + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + * dim, new_ndim, p_suboffset_dim, + * index, 0, 0, # start, stop, step # <<<<<<<<<<<<<< + * 0, 0, 0, # have_{start,stop,step} + * False) + */ + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 753, __pyx_L1_error) + + /* "View.MemoryView":750 + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): + * slice_memviewslice( # <<<<<<<<<<<<<< + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + * dim, new_ndim, p_suboffset_dim, + */ + __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_t_10, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 750, __pyx_L1_error) + + /* "View.MemoryView":749 + * + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): # <<<<<<<<<<<<<< + * slice_memviewslice( + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + */ + goto __pyx_L6; + } + + /* "View.MemoryView":756 + * 0, 0, 0, # have_{start,stop,step} + * False) + * elif index is None: # <<<<<<<<<<<<<< + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 + */ + __pyx_t_2 = (__pyx_v_index == Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":757 + * False) + * elif index is None: + * p_dst.shape[new_ndim] = 1 # <<<<<<<<<<<<<< + * p_dst.strides[new_ndim] = 0 + * p_dst.suboffsets[new_ndim] = -1 + */ + (__pyx_v_p_dst->shape[__pyx_v_new_ndim]) = 1; + + /* "View.MemoryView":758 + * elif index is None: + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 # <<<<<<<<<<<<<< + * p_dst.suboffsets[new_ndim] = -1 + * new_ndim += 1 + */ + (__pyx_v_p_dst->strides[__pyx_v_new_ndim]) = 0; + + /* "View.MemoryView":759 + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 + * p_dst.suboffsets[new_ndim] = -1 # <<<<<<<<<<<<<< + * new_ndim += 1 + * else: + */ + (__pyx_v_p_dst->suboffsets[__pyx_v_new_ndim]) = -1L; + + /* "View.MemoryView":760 + * p_dst.strides[new_ndim] = 0 + * p_dst.suboffsets[new_ndim] = -1 + * new_ndim += 1 # <<<<<<<<<<<<<< + * else: + * start = index.start or 0 + */ + __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); + + /* "View.MemoryView":756 + * 0, 0, 0, # have_{start,stop,step} + * False) + * elif index is None: # <<<<<<<<<<<<<< + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 + */ + goto __pyx_L6; + } + + /* "View.MemoryView":762 + * new_ndim += 1 + * else: + * start = index.start or 0 # <<<<<<<<<<<<<< + * stop = index.stop or 0 + * step = index.step or 0 + */ + /*else*/ { + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 762, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 762, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 762, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L7_bool_binop_done:; + __pyx_v_start = __pyx_t_10; + + /* "View.MemoryView":763 + * else: + * start = index.start or 0 + * stop = index.stop or 0 # <<<<<<<<<<<<<< + * step = index.step or 0 + * + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 763, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 763, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 763, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L9_bool_binop_done:; + __pyx_v_stop = __pyx_t_10; + + /* "View.MemoryView":764 + * start = index.start or 0 + * stop = index.stop or 0 + * step = index.step or 0 # <<<<<<<<<<<<<< + * + * have_start = index.start is not None + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 764, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 764, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 764, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L11_bool_binop_done:; + __pyx_v_step = __pyx_t_10; + + /* "View.MemoryView":766 + * step = index.step or 0 + * + * have_start = index.start is not None # <<<<<<<<<<<<<< + * have_stop = index.stop is not None + * have_step = index.step is not None + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 766, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_have_start = __pyx_t_1; + + /* "View.MemoryView":767 + * + * have_start = index.start is not None + * have_stop = index.stop is not None # <<<<<<<<<<<<<< + * have_step = index.step is not None + * + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 767, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_have_stop = __pyx_t_1; + + /* "View.MemoryView":768 + * have_start = index.start is not None + * have_stop = index.stop is not None + * have_step = index.step is not None # <<<<<<<<<<<<<< + * + * slice_memviewslice( + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 768, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_have_step = __pyx_t_1; + + /* "View.MemoryView":770 + * have_step = index.step is not None + * + * slice_memviewslice( # <<<<<<<<<<<<<< + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + * dim, new_ndim, p_suboffset_dim, + */ + __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_start, __pyx_v_stop, __pyx_v_step, __pyx_v_have_start, __pyx_v_have_stop, __pyx_v_have_step, 1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 770, __pyx_L1_error) + + /* "View.MemoryView":776 + * have_start, have_stop, have_step, + * True) + * new_ndim += 1 # <<<<<<<<<<<<<< + * + * if isinstance(memview, _memoryviewslice): + */ + __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); + } + __pyx_L6:; + + /* "View.MemoryView":748 + * cdef bint have_start, have_stop, have_step + * + * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< + * if PyIndex_Check(index): + * slice_memviewslice( + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":778 + * new_ndim += 1 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":779 + * + * if isinstance(memview, _memoryviewslice): + * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< + * memviewsliceobj.to_object_func, + * memviewsliceobj.to_dtype_func, + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + + /* "View.MemoryView":780 + * if isinstance(memview, _memoryviewslice): + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, # <<<<<<<<<<<<<< + * memviewsliceobj.to_dtype_func, + * memview.dtype_is_object) + */ + if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 780, __pyx_L1_error) } + + /* "View.MemoryView":781 + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, + * memviewsliceobj.to_dtype_func, # <<<<<<<<<<<<<< + * memview.dtype_is_object) + * else: + */ + if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 781, __pyx_L1_error) } + + /* "View.MemoryView":779 + * + * if isinstance(memview, _memoryviewslice): + * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< + * memviewsliceobj.to_object_func, + * memviewsliceobj.to_dtype_func, + */ + __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, __pyx_v_memviewsliceobj->to_object_func, __pyx_v_memviewsliceobj->to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 779, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 779, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":778 + * new_ndim += 1 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, + */ + } + + /* "View.MemoryView":784 + * memview.dtype_is_object) + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< + * memview.dtype_is_object) + * + */ + /*else*/ { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + + /* "View.MemoryView":785 + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, + * memview.dtype_is_object) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 784, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "View.MemoryView":784 + * memview.dtype_is_object) + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< + * memview.dtype_is_object) + * + */ + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 784, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":712 + * + * @cname('__pyx_memview_slice') + * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< + * cdef int new_ndim = 0, suboffset_dim = -1, dim + * cdef bint negative_step + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("View.MemoryView.memview_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_memviewsliceobj); + __Pyx_XDECREF(__pyx_v_index); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":809 + * + * @cname('__pyx_memoryview_slice_memviewslice') + * cdef int slice_memviewslice( # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, + */ + +static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, Py_ssize_t __pyx_v_shape, Py_ssize_t __pyx_v_stride, Py_ssize_t __pyx_v_suboffset, int __pyx_v_dim, int __pyx_v_new_ndim, int *__pyx_v_suboffset_dim, Py_ssize_t __pyx_v_start, Py_ssize_t __pyx_v_stop, Py_ssize_t __pyx_v_step, int __pyx_v_have_start, int __pyx_v_have_stop, int __pyx_v_have_step, int __pyx_v_is_slice) { + Py_ssize_t __pyx_v_new_shape; + int __pyx_v_negative_step; + int __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":829 + * cdef bint negative_step + * + * if not is_slice: # <<<<<<<<<<<<<< + * + * if start < 0: + */ + __pyx_t_1 = ((!(__pyx_v_is_slice != 0)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":831 + * if not is_slice: + * + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if not 0 <= start < shape: + */ + __pyx_t_1 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":832 + * + * if start < 0: + * start += shape # <<<<<<<<<<<<<< + * if not 0 <= start < shape: + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + */ + __pyx_v_start = (__pyx_v_start + __pyx_v_shape); + + /* "View.MemoryView":831 + * if not is_slice: + * + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if not 0 <= start < shape: + */ + } + + /* "View.MemoryView":833 + * if start < 0: + * start += shape + * if not 0 <= start < shape: # <<<<<<<<<<<<<< + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + * else: + */ + __pyx_t_1 = (0 <= __pyx_v_start); + if (__pyx_t_1) { + __pyx_t_1 = (__pyx_v_start < __pyx_v_shape); + } + __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":834 + * start += shape + * if not 0 <= start < shape: + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) # <<<<<<<<<<<<<< + * else: + * + */ + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"Index out of bounds (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 834, __pyx_L1_error) + + /* "View.MemoryView":833 + * if start < 0: + * start += shape + * if not 0 <= start < shape: # <<<<<<<<<<<<<< + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + * else: + */ + } + + /* "View.MemoryView":829 + * cdef bint negative_step + * + * if not is_slice: # <<<<<<<<<<<<<< + * + * if start < 0: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":837 + * else: + * + * negative_step = have_step != 0 and step < 0 # <<<<<<<<<<<<<< + * + * if have_step and step == 0: + */ + /*else*/ { + __pyx_t_1 = ((__pyx_v_have_step != 0) != 0); + if (__pyx_t_1) { + } else { + __pyx_t_2 = __pyx_t_1; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_1 = ((__pyx_v_step < 0) != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L6_bool_binop_done:; + __pyx_v_negative_step = __pyx_t_2; + + /* "View.MemoryView":839 + * negative_step = have_step != 0 and step < 0 + * + * if have_step and step == 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) + * + */ + __pyx_t_1 = (__pyx_v_have_step != 0); + if (__pyx_t_1) { + } else { + __pyx_t_2 = __pyx_t_1; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_1 = ((__pyx_v_step == 0) != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L9_bool_binop_done:; + if (__pyx_t_2) { + + /* "View.MemoryView":840 + * + * if have_step and step == 0: + * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Step may not be zero (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 840, __pyx_L1_error) + + /* "View.MemoryView":839 + * negative_step = have_step != 0 and step < 0 + * + * if have_step and step == 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) + * + */ + } + + /* "View.MemoryView":843 + * + * + * if have_start: # <<<<<<<<<<<<<< + * if start < 0: + * start += shape + */ + __pyx_t_2 = (__pyx_v_have_start != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":844 + * + * if have_start: + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if start < 0: + */ + __pyx_t_2 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":845 + * if have_start: + * if start < 0: + * start += shape # <<<<<<<<<<<<<< + * if start < 0: + * start = 0 + */ + __pyx_v_start = (__pyx_v_start + __pyx_v_shape); + + /* "View.MemoryView":846 + * if start < 0: + * start += shape + * if start < 0: # <<<<<<<<<<<<<< + * start = 0 + * elif start >= shape: + */ + __pyx_t_2 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":847 + * start += shape + * if start < 0: + * start = 0 # <<<<<<<<<<<<<< + * elif start >= shape: + * if negative_step: + */ + __pyx_v_start = 0; + + /* "View.MemoryView":846 + * if start < 0: + * start += shape + * if start < 0: # <<<<<<<<<<<<<< + * start = 0 + * elif start >= shape: + */ + } + + /* "View.MemoryView":844 + * + * if have_start: + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if start < 0: + */ + goto __pyx_L12; + } + + /* "View.MemoryView":848 + * if start < 0: + * start = 0 + * elif start >= shape: # <<<<<<<<<<<<<< + * if negative_step: + * start = shape - 1 + */ + __pyx_t_2 = ((__pyx_v_start >= __pyx_v_shape) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":849 + * start = 0 + * elif start >= shape: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":850 + * elif start >= shape: + * if negative_step: + * start = shape - 1 # <<<<<<<<<<<<<< + * else: + * start = shape + */ + __pyx_v_start = (__pyx_v_shape - 1); + + /* "View.MemoryView":849 + * start = 0 + * elif start >= shape: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + goto __pyx_L14; + } + + /* "View.MemoryView":852 + * start = shape - 1 + * else: + * start = shape # <<<<<<<<<<<<<< + * else: + * if negative_step: + */ + /*else*/ { + __pyx_v_start = __pyx_v_shape; + } + __pyx_L14:; + + /* "View.MemoryView":848 + * if start < 0: + * start = 0 + * elif start >= shape: # <<<<<<<<<<<<<< + * if negative_step: + * start = shape - 1 + */ + } + __pyx_L12:; + + /* "View.MemoryView":843 + * + * + * if have_start: # <<<<<<<<<<<<<< + * if start < 0: + * start += shape + */ + goto __pyx_L11; + } + + /* "View.MemoryView":854 + * start = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + /*else*/ { + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":855 + * else: + * if negative_step: + * start = shape - 1 # <<<<<<<<<<<<<< + * else: + * start = 0 + */ + __pyx_v_start = (__pyx_v_shape - 1); + + /* "View.MemoryView":854 + * start = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + goto __pyx_L15; + } + + /* "View.MemoryView":857 + * start = shape - 1 + * else: + * start = 0 # <<<<<<<<<<<<<< + * + * if have_stop: + */ + /*else*/ { + __pyx_v_start = 0; + } + __pyx_L15:; + } + __pyx_L11:; + + /* "View.MemoryView":859 + * start = 0 + * + * if have_stop: # <<<<<<<<<<<<<< + * if stop < 0: + * stop += shape + */ + __pyx_t_2 = (__pyx_v_have_stop != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":860 + * + * if have_stop: + * if stop < 0: # <<<<<<<<<<<<<< + * stop += shape + * if stop < 0: + */ + __pyx_t_2 = ((__pyx_v_stop < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":861 + * if have_stop: + * if stop < 0: + * stop += shape # <<<<<<<<<<<<<< + * if stop < 0: + * stop = 0 + */ + __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape); + + /* "View.MemoryView":862 + * if stop < 0: + * stop += shape + * if stop < 0: # <<<<<<<<<<<<<< + * stop = 0 + * elif stop > shape: + */ + __pyx_t_2 = ((__pyx_v_stop < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":863 + * stop += shape + * if stop < 0: + * stop = 0 # <<<<<<<<<<<<<< + * elif stop > shape: + * stop = shape + */ + __pyx_v_stop = 0; + + /* "View.MemoryView":862 + * if stop < 0: + * stop += shape + * if stop < 0: # <<<<<<<<<<<<<< + * stop = 0 + * elif stop > shape: + */ + } + + /* "View.MemoryView":860 + * + * if have_stop: + * if stop < 0: # <<<<<<<<<<<<<< + * stop += shape + * if stop < 0: + */ + goto __pyx_L17; + } + + /* "View.MemoryView":864 + * if stop < 0: + * stop = 0 + * elif stop > shape: # <<<<<<<<<<<<<< + * stop = shape + * else: + */ + __pyx_t_2 = ((__pyx_v_stop > __pyx_v_shape) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":865 + * stop = 0 + * elif stop > shape: + * stop = shape # <<<<<<<<<<<<<< + * else: + * if negative_step: + */ + __pyx_v_stop = __pyx_v_shape; + + /* "View.MemoryView":864 + * if stop < 0: + * stop = 0 + * elif stop > shape: # <<<<<<<<<<<<<< + * stop = shape + * else: + */ + } + __pyx_L17:; + + /* "View.MemoryView":859 + * start = 0 + * + * if have_stop: # <<<<<<<<<<<<<< + * if stop < 0: + * stop += shape + */ + goto __pyx_L16; + } + + /* "View.MemoryView":867 + * stop = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * stop = -1 + * else: + */ + /*else*/ { + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":868 + * else: + * if negative_step: + * stop = -1 # <<<<<<<<<<<<<< + * else: + * stop = shape + */ + __pyx_v_stop = -1L; + + /* "View.MemoryView":867 + * stop = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * stop = -1 + * else: + */ + goto __pyx_L19; + } + + /* "View.MemoryView":870 + * stop = -1 + * else: + * stop = shape # <<<<<<<<<<<<<< + * + * if not have_step: + */ + /*else*/ { + __pyx_v_stop = __pyx_v_shape; + } + __pyx_L19:; + } + __pyx_L16:; + + /* "View.MemoryView":872 + * stop = shape + * + * if not have_step: # <<<<<<<<<<<<<< + * step = 1 + * + */ + __pyx_t_2 = ((!(__pyx_v_have_step != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":873 + * + * if not have_step: + * step = 1 # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_step = 1; + + /* "View.MemoryView":872 + * stop = shape + * + * if not have_step: # <<<<<<<<<<<<<< + * step = 1 + * + */ + } + + /* "View.MemoryView":877 + * + * with cython.cdivision(True): + * new_shape = (stop - start) // step # <<<<<<<<<<<<<< + * + * if (stop - start) - step * new_shape: + */ + __pyx_v_new_shape = ((__pyx_v_stop - __pyx_v_start) / __pyx_v_step); + + /* "View.MemoryView":879 + * new_shape = (stop - start) // step + * + * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< + * new_shape += 1 + * + */ + __pyx_t_2 = (((__pyx_v_stop - __pyx_v_start) - (__pyx_v_step * __pyx_v_new_shape)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":880 + * + * if (stop - start) - step * new_shape: + * new_shape += 1 # <<<<<<<<<<<<<< + * + * if new_shape < 0: + */ + __pyx_v_new_shape = (__pyx_v_new_shape + 1); + + /* "View.MemoryView":879 + * new_shape = (stop - start) // step + * + * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< + * new_shape += 1 + * + */ + } + + /* "View.MemoryView":882 + * new_shape += 1 + * + * if new_shape < 0: # <<<<<<<<<<<<<< + * new_shape = 0 + * + */ + __pyx_t_2 = ((__pyx_v_new_shape < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":883 + * + * if new_shape < 0: + * new_shape = 0 # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_new_shape = 0; + + /* "View.MemoryView":882 + * new_shape += 1 + * + * if new_shape < 0: # <<<<<<<<<<<<<< + * new_shape = 0 + * + */ + } + + /* "View.MemoryView":886 + * + * + * dst.strides[new_ndim] = stride * step # <<<<<<<<<<<<<< + * dst.shape[new_ndim] = new_shape + * dst.suboffsets[new_ndim] = suboffset + */ + (__pyx_v_dst->strides[__pyx_v_new_ndim]) = (__pyx_v_stride * __pyx_v_step); + + /* "View.MemoryView":887 + * + * dst.strides[new_ndim] = stride * step + * dst.shape[new_ndim] = new_shape # <<<<<<<<<<<<<< + * dst.suboffsets[new_ndim] = suboffset + * + */ + (__pyx_v_dst->shape[__pyx_v_new_ndim]) = __pyx_v_new_shape; + + /* "View.MemoryView":888 + * dst.strides[new_ndim] = stride * step + * dst.shape[new_ndim] = new_shape + * dst.suboffsets[new_ndim] = suboffset # <<<<<<<<<<<<<< + * + * + */ + (__pyx_v_dst->suboffsets[__pyx_v_new_ndim]) = __pyx_v_suboffset; + } + __pyx_L3:; + + /* "View.MemoryView":891 + * + * + * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< + * dst.data += start * stride + * else: + */ + __pyx_t_2 = (((__pyx_v_suboffset_dim[0]) < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":892 + * + * if suboffset_dim[0] < 0: + * dst.data += start * stride # <<<<<<<<<<<<<< + * else: + * dst.suboffsets[suboffset_dim[0]] += start * stride + */ + __pyx_v_dst->data = (__pyx_v_dst->data + (__pyx_v_start * __pyx_v_stride)); + + /* "View.MemoryView":891 + * + * + * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< + * dst.data += start * stride + * else: + */ + goto __pyx_L23; + } + + /* "View.MemoryView":894 + * dst.data += start * stride + * else: + * dst.suboffsets[suboffset_dim[0]] += start * stride # <<<<<<<<<<<<<< + * + * if suboffset >= 0: + */ + /*else*/ { + __pyx_t_3 = (__pyx_v_suboffset_dim[0]); + (__pyx_v_dst->suboffsets[__pyx_t_3]) = ((__pyx_v_dst->suboffsets[__pyx_t_3]) + (__pyx_v_start * __pyx_v_stride)); + } + __pyx_L23:; + + /* "View.MemoryView":896 + * dst.suboffsets[suboffset_dim[0]] += start * stride + * + * if suboffset >= 0: # <<<<<<<<<<<<<< + * if not is_slice: + * if new_ndim == 0: + */ + __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":897 + * + * if suboffset >= 0: + * if not is_slice: # <<<<<<<<<<<<<< + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset + */ + __pyx_t_2 = ((!(__pyx_v_is_slice != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":898 + * if suboffset >= 0: + * if not is_slice: + * if new_ndim == 0: # <<<<<<<<<<<<<< + * dst.data = ( dst.data)[0] + suboffset + * else: + */ + __pyx_t_2 = ((__pyx_v_new_ndim == 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":899 + * if not is_slice: + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset # <<<<<<<<<<<<<< + * else: + * _err_dim(IndexError, "All dimensions preceding dimension %d " + */ + __pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset); + + /* "View.MemoryView":898 + * if suboffset >= 0: + * if not is_slice: + * if new_ndim == 0: # <<<<<<<<<<<<<< + * dst.data = ( dst.data)[0] + suboffset + * else: + */ + goto __pyx_L26; + } + + /* "View.MemoryView":901 + * dst.data = ( dst.data)[0] + suboffset + * else: + * _err_dim(IndexError, "All dimensions preceding dimension %d " # <<<<<<<<<<<<<< + * "must be indexed and not sliced", dim) + * else: + */ + /*else*/ { + + /* "View.MemoryView":902 + * else: + * _err_dim(IndexError, "All dimensions preceding dimension %d " + * "must be indexed and not sliced", dim) # <<<<<<<<<<<<<< + * else: + * suboffset_dim[0] = new_ndim + */ + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"All dimensions preceding dimension %d must be indexed and not sliced"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 901, __pyx_L1_error) + } + __pyx_L26:; + + /* "View.MemoryView":897 + * + * if suboffset >= 0: + * if not is_slice: # <<<<<<<<<<<<<< + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset + */ + goto __pyx_L25; + } + + /* "View.MemoryView":904 + * "must be indexed and not sliced", dim) + * else: + * suboffset_dim[0] = new_ndim # <<<<<<<<<<<<<< + * + * return 0 + */ + /*else*/ { + (__pyx_v_suboffset_dim[0]) = __pyx_v_new_ndim; + } + __pyx_L25:; + + /* "View.MemoryView":896 + * dst.suboffsets[suboffset_dim[0]] += start * stride + * + * if suboffset >= 0: # <<<<<<<<<<<<<< + * if not is_slice: + * if new_ndim == 0: + */ + } + + /* "View.MemoryView":906 + * suboffset_dim[0] = new_ndim + * + * return 0 # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":809 + * + * @cname('__pyx_memoryview_slice_memviewslice') + * cdef int slice_memviewslice( # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.slice_memviewslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":912 + * + * @cname('__pyx_pybuffer_index') + * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 + */ + +static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, Py_ssize_t __pyx_v_index, Py_ssize_t __pyx_v_dim) { + Py_ssize_t __pyx_v_shape; + Py_ssize_t __pyx_v_stride; + Py_ssize_t __pyx_v_suboffset; + Py_ssize_t __pyx_v_itemsize; + char *__pyx_v_resultp; + char *__pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("pybuffer_index", 0); + + /* "View.MemoryView":914 + * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 # <<<<<<<<<<<<<< + * cdef Py_ssize_t itemsize = view.itemsize + * cdef char *resultp + */ + __pyx_v_suboffset = -1L; + + /* "View.MemoryView":915 + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 + * cdef Py_ssize_t itemsize = view.itemsize # <<<<<<<<<<<<<< + * cdef char *resultp + * + */ + __pyx_t_1 = __pyx_v_view->itemsize; + __pyx_v_itemsize = __pyx_t_1; + + /* "View.MemoryView":918 + * cdef char *resultp + * + * if view.ndim == 0: # <<<<<<<<<<<<<< + * shape = view.len / itemsize + * stride = itemsize + */ + __pyx_t_2 = ((__pyx_v_view->ndim == 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":919 + * + * if view.ndim == 0: + * shape = view.len / itemsize # <<<<<<<<<<<<<< + * stride = itemsize + * else: + */ + if (unlikely(__pyx_v_itemsize == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); + __PYX_ERR(1, 919, __pyx_L1_error) + } + else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_view->len))) { + PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); + __PYX_ERR(1, 919, __pyx_L1_error) + } + __pyx_v_shape = __Pyx_div_Py_ssize_t(__pyx_v_view->len, __pyx_v_itemsize); + + /* "View.MemoryView":920 + * if view.ndim == 0: + * shape = view.len / itemsize + * stride = itemsize # <<<<<<<<<<<<<< + * else: + * shape = view.shape[dim] + */ + __pyx_v_stride = __pyx_v_itemsize; + + /* "View.MemoryView":918 + * cdef char *resultp + * + * if view.ndim == 0: # <<<<<<<<<<<<<< + * shape = view.len / itemsize + * stride = itemsize + */ + goto __pyx_L3; + } + + /* "View.MemoryView":922 + * stride = itemsize + * else: + * shape = view.shape[dim] # <<<<<<<<<<<<<< + * stride = view.strides[dim] + * if view.suboffsets != NULL: + */ + /*else*/ { + __pyx_v_shape = (__pyx_v_view->shape[__pyx_v_dim]); + + /* "View.MemoryView":923 + * else: + * shape = view.shape[dim] + * stride = view.strides[dim] # <<<<<<<<<<<<<< + * if view.suboffsets != NULL: + * suboffset = view.suboffsets[dim] + */ + __pyx_v_stride = (__pyx_v_view->strides[__pyx_v_dim]); + + /* "View.MemoryView":924 + * shape = view.shape[dim] + * stride = view.strides[dim] + * if view.suboffsets != NULL: # <<<<<<<<<<<<<< + * suboffset = view.suboffsets[dim] + * + */ + __pyx_t_2 = ((__pyx_v_view->suboffsets != NULL) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":925 + * stride = view.strides[dim] + * if view.suboffsets != NULL: + * suboffset = view.suboffsets[dim] # <<<<<<<<<<<<<< + * + * if index < 0: + */ + __pyx_v_suboffset = (__pyx_v_view->suboffsets[__pyx_v_dim]); + + /* "View.MemoryView":924 + * shape = view.shape[dim] + * stride = view.strides[dim] + * if view.suboffsets != NULL: # <<<<<<<<<<<<<< + * suboffset = view.suboffsets[dim] + * + */ + } + } + __pyx_L3:; + + /* "View.MemoryView":927 + * suboffset = view.suboffsets[dim] + * + * if index < 0: # <<<<<<<<<<<<<< + * index += view.shape[dim] + * if index < 0: + */ + __pyx_t_2 = ((__pyx_v_index < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":928 + * + * if index < 0: + * index += view.shape[dim] # <<<<<<<<<<<<<< + * if index < 0: + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + */ + __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim])); + + /* "View.MemoryView":929 + * if index < 0: + * index += view.shape[dim] + * if index < 0: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + __pyx_t_2 = ((__pyx_v_index < 0) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":930 + * index += view.shape[dim] + * if index < 0: + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<< + * + * if index >= shape: + */ + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 930, __pyx_L1_error) + + /* "View.MemoryView":929 + * if index < 0: + * index += view.shape[dim] + * if index < 0: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + } + + /* "View.MemoryView":927 + * suboffset = view.suboffsets[dim] + * + * if index < 0: # <<<<<<<<<<<<<< + * index += view.shape[dim] + * if index < 0: + */ + } + + /* "View.MemoryView":932 + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + * if index >= shape: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + __pyx_t_2 = ((__pyx_v_index >= __pyx_v_shape) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":933 + * + * if index >= shape: + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<< + * + * resultp = bufp + index * stride + */ + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 933, __pyx_L1_error) + + /* "View.MemoryView":932 + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + * if index >= shape: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + } + + /* "View.MemoryView":935 + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + * resultp = bufp + index * stride # <<<<<<<<<<<<<< + * if suboffset >= 0: + * resultp = ( resultp)[0] + suboffset + */ + __pyx_v_resultp = (__pyx_v_bufp + (__pyx_v_index * __pyx_v_stride)); + + /* "View.MemoryView":936 + * + * resultp = bufp + index * stride + * if suboffset >= 0: # <<<<<<<<<<<<<< + * resultp = ( resultp)[0] + suboffset + * + */ + __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":937 + * resultp = bufp + index * stride + * if suboffset >= 0: + * resultp = ( resultp)[0] + suboffset # <<<<<<<<<<<<<< + * + * return resultp + */ + __pyx_v_resultp = ((((char **)__pyx_v_resultp)[0]) + __pyx_v_suboffset); + + /* "View.MemoryView":936 + * + * resultp = bufp + index * stride + * if suboffset >= 0: # <<<<<<<<<<<<<< + * resultp = ( resultp)[0] + suboffset + * + */ + } + + /* "View.MemoryView":939 + * resultp = ( resultp)[0] + suboffset + * + * return resultp # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_resultp; + goto __pyx_L0; + + /* "View.MemoryView":912 + * + * @cname('__pyx_pybuffer_index') + * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView.pybuffer_index", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":945 + * + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< + * cdef int ndim = memslice.memview.view.ndim + * + */ + +static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { + int __pyx_v_ndim; + Py_ssize_t *__pyx_v_shape; + Py_ssize_t *__pyx_v_strides; + int __pyx_v_i; + int __pyx_v_j; + int __pyx_r; + int __pyx_t_1; + Py_ssize_t *__pyx_t_2; + long __pyx_t_3; + long __pyx_t_4; + Py_ssize_t __pyx_t_5; + Py_ssize_t __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":946 + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: + * cdef int ndim = memslice.memview.view.ndim # <<<<<<<<<<<<<< + * + * cdef Py_ssize_t *shape = memslice.shape + */ + __pyx_t_1 = __pyx_v_memslice->memview->view.ndim; + __pyx_v_ndim = __pyx_t_1; + + /* "View.MemoryView":948 + * cdef int ndim = memslice.memview.view.ndim + * + * cdef Py_ssize_t *shape = memslice.shape # <<<<<<<<<<<<<< + * cdef Py_ssize_t *strides = memslice.strides + * + */ + __pyx_t_2 = __pyx_v_memslice->shape; + __pyx_v_shape = __pyx_t_2; + + /* "View.MemoryView":949 + * + * cdef Py_ssize_t *shape = memslice.shape + * cdef Py_ssize_t *strides = memslice.strides # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __pyx_v_memslice->strides; + __pyx_v_strides = __pyx_t_2; + + /* "View.MemoryView":953 + * + * cdef int i, j + * for i in range(ndim / 2): # <<<<<<<<<<<<<< + * j = ndim - 1 - i + * strides[i], strides[j] = strides[j], strides[i] + */ + __pyx_t_3 = __Pyx_div_long(__pyx_v_ndim, 2); + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_1 = 0; __pyx_t_1 < __pyx_t_4; __pyx_t_1+=1) { + __pyx_v_i = __pyx_t_1; + + /* "View.MemoryView":954 + * cdef int i, j + * for i in range(ndim / 2): + * j = ndim - 1 - i # <<<<<<<<<<<<<< + * strides[i], strides[j] = strides[j], strides[i] + * shape[i], shape[j] = shape[j], shape[i] + */ + __pyx_v_j = ((__pyx_v_ndim - 1) - __pyx_v_i); + + /* "View.MemoryView":955 + * for i in range(ndim / 2): + * j = ndim - 1 - i + * strides[i], strides[j] = strides[j], strides[i] # <<<<<<<<<<<<<< + * shape[i], shape[j] = shape[j], shape[i] + * + */ + __pyx_t_5 = (__pyx_v_strides[__pyx_v_j]); + __pyx_t_6 = (__pyx_v_strides[__pyx_v_i]); + (__pyx_v_strides[__pyx_v_i]) = __pyx_t_5; + (__pyx_v_strides[__pyx_v_j]) = __pyx_t_6; + + /* "View.MemoryView":956 + * j = ndim - 1 - i + * strides[i], strides[j] = strides[j], strides[i] + * shape[i], shape[j] = shape[j], shape[i] # <<<<<<<<<<<<<< + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: + */ + __pyx_t_6 = (__pyx_v_shape[__pyx_v_j]); + __pyx_t_5 = (__pyx_v_shape[__pyx_v_i]); + (__pyx_v_shape[__pyx_v_i]) = __pyx_t_6; + (__pyx_v_shape[__pyx_v_j]) = __pyx_t_5; + + /* "View.MemoryView":958 + * shape[i], shape[j] = shape[j], shape[i] + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + */ + __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 0) != 0); + if (!__pyx_t_8) { + } else { + __pyx_t_7 = __pyx_t_8; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_j]) >= 0) != 0); + __pyx_t_7 = __pyx_t_8; + __pyx_L6_bool_binop_done:; + if (__pyx_t_7) { + + /* "View.MemoryView":959 + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") # <<<<<<<<<<<<<< + * + * return 1 + */ + __pyx_t_9 = __pyx_memoryview_err(__pyx_builtin_ValueError, ((char *)"Cannot transpose memoryview with indirect dimensions")); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 959, __pyx_L1_error) + + /* "View.MemoryView":958 + * shape[i], shape[j] = shape[j], shape[i] + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + */ + } + } + + /* "View.MemoryView":961 + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + * return 1 # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = 1; + goto __pyx_L0; + + /* "View.MemoryView":945 + * + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< + * cdef int ndim = memslice.memview.view.ndim + * + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.transpose_memslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = 0; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":978 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + */ + +/* Python wrapper */ +static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":979 + * + * def __dealloc__(self): + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<< + * + * cdef convert_item_to_object(self, char *itemp): + */ + __PYX_XDEC_MEMVIEW((&__pyx_v_self->from_slice), 1); + + /* "View.MemoryView":978 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":981 + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * if self.to_object_func != NULL: + * return self.to_object_func(itemp) + */ + +static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("convert_item_to_object", 0); + + /* "View.MemoryView":982 + * + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: # <<<<<<<<<<<<<< + * return self.to_object_func(itemp) + * else: + */ + __pyx_t_1 = ((__pyx_v_self->to_object_func != NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":983 + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: + * return self.to_object_func(itemp) # <<<<<<<<<<<<<< + * else: + * return memoryview.convert_item_to_object(self, itemp) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_v_self->to_object_func(__pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 983, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":982 + * + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: # <<<<<<<<<<<<<< + * return self.to_object_func(itemp) + * else: + */ + } + + /* "View.MemoryView":985 + * return self.to_object_func(itemp) + * else: + * return memoryview.convert_item_to_object(self, itemp) # <<<<<<<<<<<<<< + * + * cdef assign_item_from_object(self, char *itemp, object value): + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_memoryview_convert_item_to_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 985, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":981 + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * if self.to_object_func != NULL: + * return self.to_object_func(itemp) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":987 + * return memoryview.convert_item_to_object(self, itemp) + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * if self.to_dtype_func != NULL: + * self.to_dtype_func(itemp, value) + */ + +static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("assign_item_from_object", 0); + + /* "View.MemoryView":988 + * + * cdef assign_item_from_object(self, char *itemp, object value): + * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< + * self.to_dtype_func(itemp, value) + * else: + */ + __pyx_t_1 = ((__pyx_v_self->to_dtype_func != NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":989 + * cdef assign_item_from_object(self, char *itemp, object value): + * if self.to_dtype_func != NULL: + * self.to_dtype_func(itemp, value) # <<<<<<<<<<<<<< + * else: + * memoryview.assign_item_from_object(self, itemp, value) + */ + __pyx_t_2 = __pyx_v_self->to_dtype_func(__pyx_v_itemp, __pyx_v_value); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 989, __pyx_L1_error) + + /* "View.MemoryView":988 + * + * cdef assign_item_from_object(self, char *itemp, object value): + * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< + * self.to_dtype_func(itemp, value) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":991 + * self.to_dtype_func(itemp, value) + * else: + * memoryview.assign_item_from_object(self, itemp, value) # <<<<<<<<<<<<<< + * + * @property + */ + /*else*/ { + __pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 991, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L3:; + + /* "View.MemoryView":987 + * return memoryview.convert_item_to_object(self, itemp) + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * if self.to_dtype_func != NULL: + * self.to_dtype_func(itemp, value) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":994 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.from_object + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":995 + * @property + * def base(self): + * return self.from_object # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->from_object); + __pyx_r = __pyx_v_self->from_object; + goto __pyx_L0; + + /* "View.MemoryView":994 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.from_object + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_memoryviewslice___reduce_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__17, 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__18, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1001 + * + * @cname('__pyx_memoryview_fromslice') + * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< + * int ndim, + * object (*to_object_func)(char *), + */ + +static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewslice, int __pyx_v_ndim, PyObject *(*__pyx_v_to_object_func)(char *), int (*__pyx_v_to_dtype_func)(char *, PyObject *), int __pyx_v_dtype_is_object) { + struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; + Py_ssize_t __pyx_v_suboffset; + PyObject *__pyx_v_length = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_TypeInfo *__pyx_t_4; + Py_buffer __pyx_t_5; + Py_ssize_t *__pyx_t_6; + Py_ssize_t *__pyx_t_7; + Py_ssize_t *__pyx_t_8; + Py_ssize_t __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_fromslice", 0); + + /* "View.MemoryView":1009 + * cdef _memoryviewslice result + * + * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< + * return None + * + */ + __pyx_t_1 = ((((PyObject *)__pyx_v_memviewslice.memview) == Py_None) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1010 + * + * if memviewslice.memview == Py_None: + * return None # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "View.MemoryView":1009 + * cdef _memoryviewslice result + * + * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< + * return None + * + */ + } + + /* "View.MemoryView":1015 + * + * + * result = _memoryviewslice(None, 0, dtype_is_object) # <<<<<<<<<<<<<< + * + * result.from_slice = memviewslice + */ + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1015, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1015, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1015, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":1017 + * result = _memoryviewslice(None, 0, dtype_is_object) + * + * result.from_slice = memviewslice # <<<<<<<<<<<<<< + * __PYX_INC_MEMVIEW(&memviewslice, 1) + * + */ + __pyx_v_result->from_slice = __pyx_v_memviewslice; + + /* "View.MemoryView":1018 + * + * result.from_slice = memviewslice + * __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<< + * + * result.from_object = ( memviewslice.memview).base + */ + __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1); + + /* "View.MemoryView":1020 + * __PYX_INC_MEMVIEW(&memviewslice, 1) + * + * result.from_object = ( memviewslice.memview).base # <<<<<<<<<<<<<< + * result.typeinfo = memviewslice.memview.typeinfo + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_memviewslice.memview), __pyx_n_s_base); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1020, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_result->from_object); + __Pyx_DECREF(__pyx_v_result->from_object); + __pyx_v_result->from_object = __pyx_t_2; + __pyx_t_2 = 0; + + /* "View.MemoryView":1021 + * + * result.from_object = ( memviewslice.memview).base + * result.typeinfo = memviewslice.memview.typeinfo # <<<<<<<<<<<<<< + * + * result.view = memviewslice.memview.view + */ + __pyx_t_4 = __pyx_v_memviewslice.memview->typeinfo; + __pyx_v_result->__pyx_base.typeinfo = __pyx_t_4; + + /* "View.MemoryView":1023 + * result.typeinfo = memviewslice.memview.typeinfo + * + * result.view = memviewslice.memview.view # <<<<<<<<<<<<<< + * result.view.buf = memviewslice.data + * result.view.ndim = ndim + */ + __pyx_t_5 = __pyx_v_memviewslice.memview->view; + __pyx_v_result->__pyx_base.view = __pyx_t_5; + + /* "View.MemoryView":1024 + * + * result.view = memviewslice.memview.view + * result.view.buf = memviewslice.data # <<<<<<<<<<<<<< + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None + */ + __pyx_v_result->__pyx_base.view.buf = ((void *)__pyx_v_memviewslice.data); + + /* "View.MemoryView":1025 + * result.view = memviewslice.memview.view + * result.view.buf = memviewslice.data + * result.view.ndim = ndim # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &result.view).obj = Py_None + * Py_INCREF(Py_None) + */ + __pyx_v_result->__pyx_base.view.ndim = __pyx_v_ndim; + + /* "View.MemoryView":1026 + * result.view.buf = memviewslice.data + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * + */ + ((Py_buffer *)(&__pyx_v_result->__pyx_base.view))->obj = Py_None; + + /* "View.MemoryView":1027 + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: + */ + Py_INCREF(Py_None); + + /* "View.MemoryView":1029 + * Py_INCREF(Py_None) + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< + * result.flags = PyBUF_RECORDS + * else: + */ + __pyx_t_1 = ((((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->flags & PyBUF_WRITABLE) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1030 + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: + * result.flags = PyBUF_RECORDS # <<<<<<<<<<<<<< + * else: + * result.flags = PyBUF_RECORDS_RO + */ + __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS; + + /* "View.MemoryView":1029 + * Py_INCREF(Py_None) + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< + * result.flags = PyBUF_RECORDS + * else: + */ + goto __pyx_L4; + } + + /* "View.MemoryView":1032 + * result.flags = PyBUF_RECORDS + * else: + * result.flags = PyBUF_RECORDS_RO # <<<<<<<<<<<<<< + * + * result.view.shape = result.from_slice.shape + */ + /*else*/ { + __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS_RO; + } + __pyx_L4:; + + /* "View.MemoryView":1034 + * result.flags = PyBUF_RECORDS_RO + * + * result.view.shape = result.from_slice.shape # <<<<<<<<<<<<<< + * result.view.strides = result.from_slice.strides + * + */ + __pyx_v_result->__pyx_base.view.shape = ((Py_ssize_t *)__pyx_v_result->from_slice.shape); + + /* "View.MemoryView":1035 + * + * result.view.shape = result.from_slice.shape + * result.view.strides = result.from_slice.strides # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_result->__pyx_base.view.strides = ((Py_ssize_t *)__pyx_v_result->from_slice.strides); + + /* "View.MemoryView":1038 + * + * + * result.view.suboffsets = NULL # <<<<<<<<<<<<<< + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: + */ + __pyx_v_result->__pyx_base.view.suboffsets = NULL; + + /* "View.MemoryView":1039 + * + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: # <<<<<<<<<<<<<< + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets + */ + __pyx_t_7 = (__pyx_v_result->from_slice.suboffsets + __pyx_v_ndim); + for (__pyx_t_8 = __pyx_v_result->from_slice.suboffsets; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { + __pyx_t_6 = __pyx_t_8; + __pyx_v_suboffset = (__pyx_t_6[0]); + + /* "View.MemoryView":1040 + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * result.view.suboffsets = result.from_slice.suboffsets + * break + */ + __pyx_t_1 = ((__pyx_v_suboffset >= 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1041 + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets # <<<<<<<<<<<<<< + * break + * + */ + __pyx_v_result->__pyx_base.view.suboffsets = ((Py_ssize_t *)__pyx_v_result->from_slice.suboffsets); + + /* "View.MemoryView":1042 + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets + * break # <<<<<<<<<<<<<< + * + * result.view.len = result.view.itemsize + */ + goto __pyx_L6_break; + + /* "View.MemoryView":1040 + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * result.view.suboffsets = result.from_slice.suboffsets + * break + */ + } + } + __pyx_L6_break:; + + /* "View.MemoryView":1044 + * break + * + * result.view.len = result.view.itemsize # <<<<<<<<<<<<<< + * for length in result.view.shape[:ndim]: + * result.view.len *= length + */ + __pyx_t_9 = __pyx_v_result->__pyx_base.view.itemsize; + __pyx_v_result->__pyx_base.view.len = __pyx_t_9; + + /* "View.MemoryView":1045 + * + * result.view.len = result.view.itemsize + * for length in result.view.shape[:ndim]: # <<<<<<<<<<<<<< + * result.view.len *= length + * + */ + __pyx_t_7 = (__pyx_v_result->__pyx_base.view.shape + __pyx_v_ndim); + for (__pyx_t_8 = __pyx_v_result->__pyx_base.view.shape; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { + __pyx_t_6 = __pyx_t_8; + __pyx_t_2 = PyInt_FromSsize_t((__pyx_t_6[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":1046 + * result.view.len = result.view.itemsize + * for length in result.view.shape[:ndim]: + * result.view.len *= length # <<<<<<<<<<<<<< + * + * result.to_object_func = to_object_func + */ + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_result->__pyx_base.view.len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1046, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_t_2, __pyx_v_length); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1046, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 1046, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result->__pyx_base.view.len = __pyx_t_9; + } + + /* "View.MemoryView":1048 + * result.view.len *= length + * + * result.to_object_func = to_object_func # <<<<<<<<<<<<<< + * result.to_dtype_func = to_dtype_func + * + */ + __pyx_v_result->to_object_func = __pyx_v_to_object_func; + + /* "View.MemoryView":1049 + * + * result.to_object_func = to_object_func + * result.to_dtype_func = to_dtype_func # <<<<<<<<<<<<<< + * + * return result + */ + __pyx_v_result->to_dtype_func = __pyx_v_to_dtype_func; + + /* "View.MemoryView":1051 + * result.to_dtype_func = to_dtype_func + * + * return result # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "View.MemoryView":1001 + * + * @cname('__pyx_memoryview_fromslice') + * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< + * int ndim, + * object (*to_object_func)(char *), + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview_fromslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XDECREF(__pyx_v_length); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1054 + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') + * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + */ + +static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_mslice) { + struct __pyx_memoryviewslice_obj *__pyx_v_obj = 0; + __Pyx_memviewslice *__pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_slice_from_memview", 0); + + /* "View.MemoryView":1057 + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * obj = memview + * return &obj.from_slice + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1058 + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): + * obj = memview # <<<<<<<<<<<<<< + * return &obj.from_slice + * else: + */ + if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 1058, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_v_memview); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":1059 + * if isinstance(memview, _memoryviewslice): + * obj = memview + * return &obj.from_slice # <<<<<<<<<<<<<< + * else: + * slice_copy(memview, mslice) + */ + __pyx_r = (&__pyx_v_obj->from_slice); + goto __pyx_L0; + + /* "View.MemoryView":1057 + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * obj = memview + * return &obj.from_slice + */ + } + + /* "View.MemoryView":1061 + * return &obj.from_slice + * else: + * slice_copy(memview, mslice) # <<<<<<<<<<<<<< + * return mslice + * + */ + /*else*/ { + __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice); + + /* "View.MemoryView":1062 + * else: + * slice_copy(memview, mslice) + * return mslice # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_slice_copy') + */ + __pyx_r = __pyx_v_mslice; + goto __pyx_L0; + } + + /* "View.MemoryView":1054 + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') + * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.get_slice_from_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_obj); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1065 + * + * @cname('__pyx_memoryview_slice_copy') + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< + * cdef int dim + * cdef (Py_ssize_t*) shape, strides, suboffsets + */ + +static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_dst) { + int __pyx_v_dim; + Py_ssize_t *__pyx_v_shape; + Py_ssize_t *__pyx_v_strides; + Py_ssize_t *__pyx_v_suboffsets; + __Pyx_RefNannyDeclarations + Py_ssize_t *__pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + Py_ssize_t __pyx_t_5; + __Pyx_RefNannySetupContext("slice_copy", 0); + + /* "View.MemoryView":1069 + * cdef (Py_ssize_t*) shape, strides, suboffsets + * + * shape = memview.view.shape # <<<<<<<<<<<<<< + * strides = memview.view.strides + * suboffsets = memview.view.suboffsets + */ + __pyx_t_1 = __pyx_v_memview->view.shape; + __pyx_v_shape = __pyx_t_1; + + /* "View.MemoryView":1070 + * + * shape = memview.view.shape + * strides = memview.view.strides # <<<<<<<<<<<<<< + * suboffsets = memview.view.suboffsets + * + */ + __pyx_t_1 = __pyx_v_memview->view.strides; + __pyx_v_strides = __pyx_t_1; + + /* "View.MemoryView":1071 + * shape = memview.view.shape + * strides = memview.view.strides + * suboffsets = memview.view.suboffsets # <<<<<<<<<<<<<< + * + * dst.memview = <__pyx_memoryview *> memview + */ + __pyx_t_1 = __pyx_v_memview->view.suboffsets; + __pyx_v_suboffsets = __pyx_t_1; + + /* "View.MemoryView":1073 + * suboffsets = memview.view.suboffsets + * + * dst.memview = <__pyx_memoryview *> memview # <<<<<<<<<<<<<< + * dst.data = memview.view.buf + * + */ + __pyx_v_dst->memview = ((struct __pyx_memoryview_obj *)__pyx_v_memview); + + /* "View.MemoryView":1074 + * + * dst.memview = <__pyx_memoryview *> memview + * dst.data = memview.view.buf # <<<<<<<<<<<<<< + * + * for dim in range(memview.view.ndim): + */ + __pyx_v_dst->data = ((char *)__pyx_v_memview->view.buf); + + /* "View.MemoryView":1076 + * dst.data = memview.view.buf + * + * for dim in range(memview.view.ndim): # <<<<<<<<<<<<<< + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] + */ + __pyx_t_2 = __pyx_v_memview->view.ndim; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_dim = __pyx_t_4; + + /* "View.MemoryView":1077 + * + * for dim in range(memview.view.ndim): + * dst.shape[dim] = shape[dim] # <<<<<<<<<<<<<< + * dst.strides[dim] = strides[dim] + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 + */ + (__pyx_v_dst->shape[__pyx_v_dim]) = (__pyx_v_shape[__pyx_v_dim]); + + /* "View.MemoryView":1078 + * for dim in range(memview.view.ndim): + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] # <<<<<<<<<<<<<< + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 + * + */ + (__pyx_v_dst->strides[__pyx_v_dim]) = (__pyx_v_strides[__pyx_v_dim]); + + /* "View.MemoryView":1079 + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_object') + */ + if ((__pyx_v_suboffsets != 0)) { + __pyx_t_5 = (__pyx_v_suboffsets[__pyx_v_dim]); + } else { + __pyx_t_5 = -1L; + } + (__pyx_v_dst->suboffsets[__pyx_v_dim]) = __pyx_t_5; + } + + /* "View.MemoryView":1065 + * + * @cname('__pyx_memoryview_slice_copy') + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< + * cdef int dim + * cdef (Py_ssize_t*) shape, strides, suboffsets + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":1082 + * + * @cname('__pyx_memoryview_copy_object') + * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< + * "Create a new memoryview object" + * cdef __Pyx_memviewslice memviewslice + */ + +static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx_v_memview) { + __Pyx_memviewslice __pyx_v_memviewslice; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_copy", 0); + + /* "View.MemoryView":1085 + * "Create a new memoryview object" + * cdef __Pyx_memviewslice memviewslice + * slice_copy(memview, &memviewslice) # <<<<<<<<<<<<<< + * return memoryview_copy_from_slice(memview, &memviewslice) + * + */ + __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_memviewslice)); + + /* "View.MemoryView":1086 + * cdef __Pyx_memviewslice memviewslice + * slice_copy(memview, &memviewslice) + * return memoryview_copy_from_slice(memview, &memviewslice) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_object_from_slice') + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_memoryview_copy_object_from_slice(__pyx_v_memview, (&__pyx_v_memviewslice)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1086, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":1082 + * + * @cname('__pyx_memoryview_copy_object') + * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< + * "Create a new memoryview object" + * cdef __Pyx_memviewslice memviewslice + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview_copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1089 + * + * @cname('__pyx_memoryview_copy_object_from_slice') + * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< + * """ + * Create a new memoryview object from a given memoryview object and slice. + */ + +static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_memviewslice) { + PyObject *(*__pyx_v_to_object_func)(char *); + int (*__pyx_v_to_dtype_func)(char *, PyObject *); + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *(*__pyx_t_3)(char *); + int (*__pyx_t_4)(char *, PyObject *); + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 0); + + /* "View.MemoryView":1096 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1097 + * + * if isinstance(memview, _memoryviewslice): + * to_object_func = (<_memoryviewslice> memview).to_object_func # <<<<<<<<<<<<<< + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + * else: + */ + __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func; + __pyx_v_to_object_func = __pyx_t_3; + + /* "View.MemoryView":1098 + * if isinstance(memview, _memoryviewslice): + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func # <<<<<<<<<<<<<< + * else: + * to_object_func = NULL + */ + __pyx_t_4 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func; + __pyx_v_to_dtype_func = __pyx_t_4; + + /* "View.MemoryView":1096 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1100 + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + * else: + * to_object_func = NULL # <<<<<<<<<<<<<< + * to_dtype_func = NULL + * + */ + /*else*/ { + __pyx_v_to_object_func = NULL; + + /* "View.MemoryView":1101 + * else: + * to_object_func = NULL + * to_dtype_func = NULL # <<<<<<<<<<<<<< + * + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, + */ + __pyx_v_to_dtype_func = NULL; + } + __pyx_L3:; + + /* "View.MemoryView":1103 + * to_dtype_func = NULL + * + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, # <<<<<<<<<<<<<< + * to_object_func, to_dtype_func, + * memview.dtype_is_object) + */ + __Pyx_XDECREF(__pyx_r); + + /* "View.MemoryView":1105 + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, + * to_object_func, to_dtype_func, + * memview.dtype_is_object) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __pyx_memoryview_fromslice((__pyx_v_memviewslice[0]), __pyx_v_memview->view.ndim, __pyx_v_to_object_func, __pyx_v_to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "View.MemoryView":1089 + * + * @cname('__pyx_memoryview_copy_object_from_slice') + * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< + * """ + * Create a new memoryview object from a given memoryview object and slice. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview_copy_from_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1111 + * + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< + * if arg < 0: + * return -arg + */ + +static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { + Py_ssize_t __pyx_r; + int __pyx_t_1; + + /* "View.MemoryView":1112 + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: # <<<<<<<<<<<<<< + * return -arg + * else: + */ + __pyx_t_1 = ((__pyx_v_arg < 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1113 + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: + * return -arg # <<<<<<<<<<<<<< + * else: + * return arg + */ + __pyx_r = (-__pyx_v_arg); + goto __pyx_L0; + + /* "View.MemoryView":1112 + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: # <<<<<<<<<<<<<< + * return -arg + * else: + */ + } + + /* "View.MemoryView":1115 + * return -arg + * else: + * return arg # <<<<<<<<<<<<<< + * + * @cname('__pyx_get_best_slice_order') + */ + /*else*/ { + __pyx_r = __pyx_v_arg; + goto __pyx_L0; + } + + /* "View.MemoryView":1111 + * + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< + * if arg < 0: + * return -arg + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1118 + * + * @cname('__pyx_get_best_slice_order') + * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< + * """ + * Figure out the best memory access order for a given slice. + */ + +static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim) { + int __pyx_v_i; + Py_ssize_t __pyx_v_c_stride; + Py_ssize_t __pyx_v_f_stride; + char __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + + /* "View.MemoryView":1123 + * """ + * cdef int i + * cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<< + * cdef Py_ssize_t f_stride = 0 + * + */ + __pyx_v_c_stride = 0; + + /* "View.MemoryView":1124 + * cdef int i + * cdef Py_ssize_t c_stride = 0 + * cdef Py_ssize_t f_stride = 0 # <<<<<<<<<<<<<< + * + * for i in range(ndim - 1, -1, -1): + */ + __pyx_v_f_stride = 0; + + /* "View.MemoryView":1126 + * cdef Py_ssize_t f_stride = 0 + * + * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] + */ + for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { + __pyx_v_i = __pyx_t_1; + + /* "View.MemoryView":1127 + * + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * c_stride = mslice.strides[i] + * break + */ + __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1128 + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] # <<<<<<<<<<<<<< + * break + * + */ + __pyx_v_c_stride = (__pyx_v_mslice->strides[__pyx_v_i]); + + /* "View.MemoryView":1129 + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] + * break # <<<<<<<<<<<<<< + * + * for i in range(ndim): + */ + goto __pyx_L4_break; + + /* "View.MemoryView":1127 + * + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * c_stride = mslice.strides[i] + * break + */ + } + } + __pyx_L4_break:; + + /* "View.MemoryView":1131 + * break + * + * for i in range(ndim): # <<<<<<<<<<<<<< + * if mslice.shape[i] > 1: + * f_stride = mslice.strides[i] + */ + __pyx_t_1 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_1; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1132 + * + * for i in range(ndim): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * f_stride = mslice.strides[i] + * break + */ + __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1133 + * for i in range(ndim): + * if mslice.shape[i] > 1: + * f_stride = mslice.strides[i] # <<<<<<<<<<<<<< + * break + * + */ + __pyx_v_f_stride = (__pyx_v_mslice->strides[__pyx_v_i]); + + /* "View.MemoryView":1134 + * if mslice.shape[i] > 1: + * f_stride = mslice.strides[i] + * break # <<<<<<<<<<<<<< + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): + */ + goto __pyx_L7_break; + + /* "View.MemoryView":1132 + * + * for i in range(ndim): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * f_stride = mslice.strides[i] + * break + */ + } + } + __pyx_L7_break:; + + /* "View.MemoryView":1136 + * break + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< + * return 'C' + * else: + */ + __pyx_t_2 = ((abs_py_ssize_t(__pyx_v_c_stride) <= abs_py_ssize_t(__pyx_v_f_stride)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1137 + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): + * return 'C' # <<<<<<<<<<<<<< + * else: + * return 'F' + */ + __pyx_r = 'C'; + goto __pyx_L0; + + /* "View.MemoryView":1136 + * break + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< + * return 'C' + * else: + */ + } + + /* "View.MemoryView":1139 + * return 'C' + * else: + * return 'F' # <<<<<<<<<<<<<< + * + * @cython.cdivision(True) + */ + /*else*/ { + __pyx_r = 'F'; + goto __pyx_L0; + } + + /* "View.MemoryView":1118 + * + * @cname('__pyx_get_best_slice_order') + * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< + * """ + * Figure out the best memory access order for a given slice. + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1142 + * + * @cython.cdivision(True) + * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< + * char *dst_data, Py_ssize_t *dst_strides, + * Py_ssize_t *src_shape, Py_ssize_t *dst_shape, + */ + +static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v_src_strides, char *__pyx_v_dst_data, Py_ssize_t *__pyx_v_dst_strides, Py_ssize_t *__pyx_v_src_shape, Py_ssize_t *__pyx_v_dst_shape, int __pyx_v_ndim, size_t __pyx_v_itemsize) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + CYTHON_UNUSED Py_ssize_t __pyx_v_src_extent; + Py_ssize_t __pyx_v_dst_extent; + Py_ssize_t __pyx_v_src_stride; + Py_ssize_t __pyx_v_dst_stride; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + Py_ssize_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + Py_ssize_t __pyx_t_6; + + /* "View.MemoryView":1149 + * + * cdef Py_ssize_t i + * cdef Py_ssize_t src_extent = src_shape[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t dst_extent = dst_shape[0] + * cdef Py_ssize_t src_stride = src_strides[0] + */ + __pyx_v_src_extent = (__pyx_v_src_shape[0]); + + /* "View.MemoryView":1150 + * cdef Py_ssize_t i + * cdef Py_ssize_t src_extent = src_shape[0] + * cdef Py_ssize_t dst_extent = dst_shape[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t src_stride = src_strides[0] + * cdef Py_ssize_t dst_stride = dst_strides[0] + */ + __pyx_v_dst_extent = (__pyx_v_dst_shape[0]); + + /* "View.MemoryView":1151 + * cdef Py_ssize_t src_extent = src_shape[0] + * cdef Py_ssize_t dst_extent = dst_shape[0] + * cdef Py_ssize_t src_stride = src_strides[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t dst_stride = dst_strides[0] + * + */ + __pyx_v_src_stride = (__pyx_v_src_strides[0]); + + /* "View.MemoryView":1152 + * cdef Py_ssize_t dst_extent = dst_shape[0] + * cdef Py_ssize_t src_stride = src_strides[0] + * cdef Py_ssize_t dst_stride = dst_strides[0] # <<<<<<<<<<<<<< + * + * if ndim == 1: + */ + __pyx_v_dst_stride = (__pyx_v_dst_strides[0]); + + /* "View.MemoryView":1154 + * cdef Py_ssize_t dst_stride = dst_strides[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): + */ + __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1155 + * + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) + */ + __pyx_t_2 = ((__pyx_v_src_stride > 0) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L5_bool_binop_done; + } + __pyx_t_2 = ((__pyx_v_dst_stride > 0) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L5_bool_binop_done; + } + + /* "View.MemoryView":1156 + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): # <<<<<<<<<<<<<< + * memcpy(dst_data, src_data, itemsize * dst_extent) + * else: + */ + __pyx_t_2 = (((size_t)__pyx_v_src_stride) == __pyx_v_itemsize); + if (__pyx_t_2) { + __pyx_t_2 = (__pyx_v_itemsize == ((size_t)__pyx_v_dst_stride)); + } + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L5_bool_binop_done:; + + /* "View.MemoryView":1155 + * + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) + */ + if (__pyx_t_1) { + + /* "View.MemoryView":1157 + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) # <<<<<<<<<<<<<< + * else: + * for i in range(dst_extent): + */ + (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, (__pyx_v_itemsize * __pyx_v_dst_extent))); + + /* "View.MemoryView":1155 + * + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) + */ + goto __pyx_L4; + } + + /* "View.MemoryView":1159 + * memcpy(dst_data, src_data, itemsize * dst_extent) + * else: + * for i in range(dst_extent): # <<<<<<<<<<<<<< + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride + */ + /*else*/ { + __pyx_t_4 = __pyx_v_dst_extent; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1160 + * else: + * for i in range(dst_extent): + * memcpy(dst_data, src_data, itemsize) # <<<<<<<<<<<<<< + * src_data += src_stride + * dst_data += dst_stride + */ + (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, __pyx_v_itemsize)); + + /* "View.MemoryView":1161 + * for i in range(dst_extent): + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride # <<<<<<<<<<<<<< + * dst_data += dst_stride + * else: + */ + __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); + + /* "View.MemoryView":1162 + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride + * dst_data += dst_stride # <<<<<<<<<<<<<< + * else: + * for i in range(dst_extent): + */ + __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); + } + } + __pyx_L4:; + + /* "View.MemoryView":1154 + * cdef Py_ssize_t dst_stride = dst_strides[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1164 + * dst_data += dst_stride + * else: + * for i in range(dst_extent): # <<<<<<<<<<<<<< + * _copy_strided_to_strided(src_data, src_strides + 1, + * dst_data, dst_strides + 1, + */ + /*else*/ { + __pyx_t_4 = __pyx_v_dst_extent; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1165 + * else: + * for i in range(dst_extent): + * _copy_strided_to_strided(src_data, src_strides + 1, # <<<<<<<<<<<<<< + * dst_data, dst_strides + 1, + * src_shape + 1, dst_shape + 1, + */ + _copy_strided_to_strided(__pyx_v_src_data, (__pyx_v_src_strides + 1), __pyx_v_dst_data, (__pyx_v_dst_strides + 1), (__pyx_v_src_shape + 1), (__pyx_v_dst_shape + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize); + + /* "View.MemoryView":1169 + * src_shape + 1, dst_shape + 1, + * ndim - 1, itemsize) + * src_data += src_stride # <<<<<<<<<<<<<< + * dst_data += dst_stride + * + */ + __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); + + /* "View.MemoryView":1170 + * ndim - 1, itemsize) + * src_data += src_stride + * dst_data += dst_stride # <<<<<<<<<<<<<< + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, + */ + __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); + } + } + __pyx_L3:; + + /* "View.MemoryView":1142 + * + * @cython.cdivision(True) + * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< + * char *dst_data, Py_ssize_t *dst_strides, + * Py_ssize_t *src_shape, Py_ssize_t *dst_shape, + */ + + /* function exit code */ +} + +/* "View.MemoryView":1172 + * dst_data += dst_stride + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) nogil: + */ + +static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize) { + + /* "View.MemoryView":1175 + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) nogil: + * _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides, # <<<<<<<<<<<<<< + * src.shape, dst.shape, ndim, itemsize) + * + */ + _copy_strided_to_strided(__pyx_v_src->data, __pyx_v_src->strides, __pyx_v_dst->data, __pyx_v_dst->strides, __pyx_v_src->shape, __pyx_v_dst->shape, __pyx_v_ndim, __pyx_v_itemsize); + + /* "View.MemoryView":1172 + * dst_data += dst_stride + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1179 + * + * @cname('__pyx_memoryview_slice_get_size') + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< + * "Return the size of the memory occupied by the slice in number of bytes" + * cdef Py_ssize_t shape, size = src.memview.view.itemsize + */ + +static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_src, int __pyx_v_ndim) { + Py_ssize_t __pyx_v_shape; + Py_ssize_t __pyx_v_size; + Py_ssize_t __pyx_r; + Py_ssize_t __pyx_t_1; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + + /* "View.MemoryView":1181 + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: + * "Return the size of the memory occupied by the slice in number of bytes" + * cdef Py_ssize_t shape, size = src.memview.view.itemsize # <<<<<<<<<<<<<< + * + * for shape in src.shape[:ndim]: + */ + __pyx_t_1 = __pyx_v_src->memview->view.itemsize; + __pyx_v_size = __pyx_t_1; + + /* "View.MemoryView":1183 + * cdef Py_ssize_t shape, size = src.memview.view.itemsize + * + * for shape in src.shape[:ndim]: # <<<<<<<<<<<<<< + * size *= shape + * + */ + __pyx_t_3 = (__pyx_v_src->shape + __pyx_v_ndim); + for (__pyx_t_4 = __pyx_v_src->shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { + __pyx_t_2 = __pyx_t_4; + __pyx_v_shape = (__pyx_t_2[0]); + + /* "View.MemoryView":1184 + * + * for shape in src.shape[:ndim]: + * size *= shape # <<<<<<<<<<<<<< + * + * return size + */ + __pyx_v_size = (__pyx_v_size * __pyx_v_shape); + } + + /* "View.MemoryView":1186 + * size *= shape + * + * return size # <<<<<<<<<<<<<< + * + * @cname('__pyx_fill_contig_strides_array') + */ + __pyx_r = __pyx_v_size; + goto __pyx_L0; + + /* "View.MemoryView":1179 + * + * @cname('__pyx_memoryview_slice_get_size') + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< + * "Return the size of the memory occupied by the slice in number of bytes" + * cdef Py_ssize_t shape, size = src.memview.view.itemsize + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1189 + * + * @cname('__pyx_fill_contig_strides_array') + * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< + * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, + * int ndim, char order) nogil: + */ + +static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, Py_ssize_t __pyx_v_stride, int __pyx_v_ndim, char __pyx_v_order) { + int __pyx_v_idx; + Py_ssize_t __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + + /* "View.MemoryView":1198 + * cdef int idx + * + * if order == 'F': # <<<<<<<<<<<<<< + * for idx in range(ndim): + * strides[idx] = stride + */ + __pyx_t_1 = ((__pyx_v_order == 'F') != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1199 + * + * if order == 'F': + * for idx in range(ndim): # <<<<<<<<<<<<<< + * strides[idx] = stride + * stride *= shape[idx] + */ + __pyx_t_2 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_idx = __pyx_t_4; + + /* "View.MemoryView":1200 + * if order == 'F': + * for idx in range(ndim): + * strides[idx] = stride # <<<<<<<<<<<<<< + * stride *= shape[idx] + * else: + */ + (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; + + /* "View.MemoryView":1201 + * for idx in range(ndim): + * strides[idx] = stride + * stride *= shape[idx] # <<<<<<<<<<<<<< + * else: + * for idx in range(ndim - 1, -1, -1): + */ + __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); + } + + /* "View.MemoryView":1198 + * cdef int idx + * + * if order == 'F': # <<<<<<<<<<<<<< + * for idx in range(ndim): + * strides[idx] = stride + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1203 + * stride *= shape[idx] + * else: + * for idx in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< + * strides[idx] = stride + * stride *= shape[idx] + */ + /*else*/ { + for (__pyx_t_2 = (__pyx_v_ndim - 1); __pyx_t_2 > -1; __pyx_t_2-=1) { + __pyx_v_idx = __pyx_t_2; + + /* "View.MemoryView":1204 + * else: + * for idx in range(ndim - 1, -1, -1): + * strides[idx] = stride # <<<<<<<<<<<<<< + * stride *= shape[idx] + * + */ + (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; + + /* "View.MemoryView":1205 + * for idx in range(ndim - 1, -1, -1): + * strides[idx] = stride + * stride *= shape[idx] # <<<<<<<<<<<<<< + * + * return stride + */ + __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); + } + } + __pyx_L3:; + + /* "View.MemoryView":1207 + * stride *= shape[idx] + * + * return stride # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_data_to_temp') + */ + __pyx_r = __pyx_v_stride; + goto __pyx_L0; + + /* "View.MemoryView":1189 + * + * @cname('__pyx_fill_contig_strides_array') + * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< + * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, + * int ndim, char order) nogil: + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1210 + * + * @cname('__pyx_memoryview_copy_data_to_temp') + * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *tmpslice, + * char order, + */ + +static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_tmpslice, char __pyx_v_order, int __pyx_v_ndim) { + int __pyx_v_i; + void *__pyx_v_result; + size_t __pyx_v_itemsize; + size_t __pyx_v_size; + void *__pyx_r; + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + struct __pyx_memoryview_obj *__pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":1221 + * cdef void *result + * + * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< + * cdef size_t size = slice_get_size(src, ndim) + * + */ + __pyx_t_1 = __pyx_v_src->memview->view.itemsize; + __pyx_v_itemsize = __pyx_t_1; + + /* "View.MemoryView":1222 + * + * cdef size_t itemsize = src.memview.view.itemsize + * cdef size_t size = slice_get_size(src, ndim) # <<<<<<<<<<<<<< + * + * result = malloc(size) + */ + __pyx_v_size = __pyx_memoryview_slice_get_size(__pyx_v_src, __pyx_v_ndim); + + /* "View.MemoryView":1224 + * cdef size_t size = slice_get_size(src, ndim) + * + * result = malloc(size) # <<<<<<<<<<<<<< + * if not result: + * _err(MemoryError, NULL) + */ + __pyx_v_result = malloc(__pyx_v_size); + + /* "View.MemoryView":1225 + * + * result = malloc(size) + * if not result: # <<<<<<<<<<<<<< + * _err(MemoryError, NULL) + * + */ + __pyx_t_2 = ((!(__pyx_v_result != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1226 + * result = malloc(size) + * if not result: + * _err(MemoryError, NULL) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_memoryview_err(__pyx_builtin_MemoryError, NULL); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 1226, __pyx_L1_error) + + /* "View.MemoryView":1225 + * + * result = malloc(size) + * if not result: # <<<<<<<<<<<<<< + * _err(MemoryError, NULL) + * + */ + } + + /* "View.MemoryView":1229 + * + * + * tmpslice.data = result # <<<<<<<<<<<<<< + * tmpslice.memview = src.memview + * for i in range(ndim): + */ + __pyx_v_tmpslice->data = ((char *)__pyx_v_result); + + /* "View.MemoryView":1230 + * + * tmpslice.data = result + * tmpslice.memview = src.memview # <<<<<<<<<<<<<< + * for i in range(ndim): + * tmpslice.shape[i] = src.shape[i] + */ + __pyx_t_4 = __pyx_v_src->memview; + __pyx_v_tmpslice->memview = __pyx_t_4; + + /* "View.MemoryView":1231 + * tmpslice.data = result + * tmpslice.memview = src.memview + * for i in range(ndim): # <<<<<<<<<<<<<< + * tmpslice.shape[i] = src.shape[i] + * tmpslice.suboffsets[i] = -1 + */ + __pyx_t_3 = __pyx_v_ndim; + __pyx_t_5 = __pyx_t_3; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1232 + * tmpslice.memview = src.memview + * for i in range(ndim): + * tmpslice.shape[i] = src.shape[i] # <<<<<<<<<<<<<< + * tmpslice.suboffsets[i] = -1 + * + */ + (__pyx_v_tmpslice->shape[__pyx_v_i]) = (__pyx_v_src->shape[__pyx_v_i]); + + /* "View.MemoryView":1233 + * for i in range(ndim): + * tmpslice.shape[i] = src.shape[i] + * tmpslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< + * + * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, + */ + (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L; + } + + /* "View.MemoryView":1235 + * tmpslice.suboffsets[i] = -1 + * + * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, # <<<<<<<<<<<<<< + * ndim, order) + * + */ + (void)(__pyx_fill_contig_strides_array((&(__pyx_v_tmpslice->shape[0])), (&(__pyx_v_tmpslice->strides[0])), __pyx_v_itemsize, __pyx_v_ndim, __pyx_v_order)); + + /* "View.MemoryView":1239 + * + * + * for i in range(ndim): # <<<<<<<<<<<<<< + * if tmpslice.shape[i] == 1: + * tmpslice.strides[i] = 0 + */ + __pyx_t_3 = __pyx_v_ndim; + __pyx_t_5 = __pyx_t_3; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1240 + * + * for i in range(ndim): + * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< + * tmpslice.strides[i] = 0 + * + */ + __pyx_t_2 = (((__pyx_v_tmpslice->shape[__pyx_v_i]) == 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1241 + * for i in range(ndim): + * if tmpslice.shape[i] == 1: + * tmpslice.strides[i] = 0 # <<<<<<<<<<<<<< + * + * if slice_is_contig(src[0], order, ndim): + */ + (__pyx_v_tmpslice->strides[__pyx_v_i]) = 0; + + /* "View.MemoryView":1240 + * + * for i in range(ndim): + * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< + * tmpslice.strides[i] = 0 + * + */ + } + } + + /* "View.MemoryView":1243 + * tmpslice.strides[i] = 0 + * + * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< + * memcpy(result, src.data, size) + * else: + */ + __pyx_t_2 = (__pyx_memviewslice_is_contig((__pyx_v_src[0]), __pyx_v_order, __pyx_v_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1244 + * + * if slice_is_contig(src[0], order, ndim): + * memcpy(result, src.data, size) # <<<<<<<<<<<<<< + * else: + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) + */ + (void)(memcpy(__pyx_v_result, __pyx_v_src->data, __pyx_v_size)); + + /* "View.MemoryView":1243 + * tmpslice.strides[i] = 0 + * + * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< + * memcpy(result, src.data, size) + * else: + */ + goto __pyx_L9; + } + + /* "View.MemoryView":1246 + * memcpy(result, src.data, size) + * else: + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) # <<<<<<<<<<<<<< + * + * return result + */ + /*else*/ { + copy_strided_to_strided(__pyx_v_src, __pyx_v_tmpslice, __pyx_v_ndim, __pyx_v_itemsize); + } + __pyx_L9:; + + /* "View.MemoryView":1248 + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) + * + * return result # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "View.MemoryView":1210 + * + * @cname('__pyx_memoryview_copy_data_to_temp') + * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *tmpslice, + * char order, + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.copy_data_to_temp", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = NULL; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1253 + * + * @cname('__pyx_memoryview_err_extents') + * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % + */ + +static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent1, Py_ssize_t __pyx_v_extent2) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("_err_extents", 0); + + /* "View.MemoryView":1256 + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % + * (i, extent1, extent2)) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_err_dim') + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_extent1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_extent2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + + /* "View.MemoryView":1255 + * cdef int _err_extents(int i, Py_ssize_t extent1, + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % # <<<<<<<<<<<<<< + * (i, extent1, extent2)) + * + */ + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 1255, __pyx_L1_error) + + /* "View.MemoryView":1253 + * + * @cname('__pyx_memoryview_err_extents') + * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView._err_extents", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "View.MemoryView":1259 + * + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii') % dim) + * + */ + +static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, int __pyx_v_dim) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("_err_dim", 0); + __Pyx_INCREF(__pyx_v_error); + + /* "View.MemoryView":1260 + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: + * raise error(msg.decode('ascii') % dim) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_err') + */ + __pyx_t_2 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyUnicode_Format(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_INCREF(__pyx_v_error); + __pyx_t_3 = __pyx_v_error; __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 1260, __pyx_L1_error) + + /* "View.MemoryView":1259 + * + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii') % dim) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView._err_dim", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_XDECREF(__pyx_v_error); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "View.MemoryView":1263 + * + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< + * if msg != NULL: + * raise error(msg.decode('ascii')) + */ + +static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("_err", 0); + __Pyx_INCREF(__pyx_v_error); + + /* "View.MemoryView":1264 + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: + * if msg != NULL: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii')) + * else: + */ + __pyx_t_1 = ((__pyx_v_msg != NULL) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":1265 + * cdef int _err(object error, char *msg) except -1 with gil: + * if msg != NULL: + * raise error(msg.decode('ascii')) # <<<<<<<<<<<<<< + * else: + * raise error + */ + __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_error); + __pyx_t_4 = __pyx_v_error; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 1265, __pyx_L1_error) + + /* "View.MemoryView":1264 + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: + * if msg != NULL: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii')) + * else: + */ + } + + /* "View.MemoryView":1267 + * raise error(msg.decode('ascii')) + * else: + * raise error # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_contents') + */ + /*else*/ { + __Pyx_Raise(__pyx_v_error, 0, 0, 0); + __PYX_ERR(1, 1267, __pyx_L1_error) + } + + /* "View.MemoryView":1263 + * + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< + * if msg != NULL: + * raise error(msg.decode('ascii')) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView._err", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_XDECREF(__pyx_v_error); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "View.MemoryView":1270 + * + * @cname('__pyx_memoryview_copy_contents') + * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice dst, + * int src_ndim, int dst_ndim, + */ + +static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_memviewslice __pyx_v_dst, int __pyx_v_src_ndim, int __pyx_v_dst_ndim, int __pyx_v_dtype_is_object) { + void *__pyx_v_tmpdata; + size_t __pyx_v_itemsize; + int __pyx_v_i; + char __pyx_v_order; + int __pyx_v_broadcasting; + int __pyx_v_direct_copy; + __Pyx_memviewslice __pyx_v_tmp; + int __pyx_v_ndim; + int __pyx_r; + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + void *__pyx_t_7; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":1278 + * Check for overlapping memory and verify the shapes. + * """ + * cdef void *tmpdata = NULL # <<<<<<<<<<<<<< + * cdef size_t itemsize = src.memview.view.itemsize + * cdef int i + */ + __pyx_v_tmpdata = NULL; + + /* "View.MemoryView":1279 + * """ + * cdef void *tmpdata = NULL + * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) + */ + __pyx_t_1 = __pyx_v_src.memview->view.itemsize; + __pyx_v_itemsize = __pyx_t_1; + + /* "View.MemoryView":1281 + * cdef size_t itemsize = src.memview.view.itemsize + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) # <<<<<<<<<<<<<< + * cdef bint broadcasting = False + * cdef bint direct_copy = False + */ + __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_src), __pyx_v_src_ndim); + + /* "View.MemoryView":1282 + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) + * cdef bint broadcasting = False # <<<<<<<<<<<<<< + * cdef bint direct_copy = False + * cdef __Pyx_memviewslice tmp + */ + __pyx_v_broadcasting = 0; + + /* "View.MemoryView":1283 + * cdef char order = get_best_order(&src, src_ndim) + * cdef bint broadcasting = False + * cdef bint direct_copy = False # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice tmp + * + */ + __pyx_v_direct_copy = 0; + + /* "View.MemoryView":1286 + * cdef __Pyx_memviewslice tmp + * + * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: + */ + __pyx_t_2 = ((__pyx_v_src_ndim < __pyx_v_dst_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1287 + * + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) # <<<<<<<<<<<<<< + * elif dst_ndim < src_ndim: + * broadcast_leading(&dst, dst_ndim, src_ndim) + */ + __pyx_memoryview_broadcast_leading((&__pyx_v_src), __pyx_v_src_ndim, __pyx_v_dst_ndim); + + /* "View.MemoryView":1286 + * cdef __Pyx_memviewslice tmp + * + * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1288 + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&dst, dst_ndim, src_ndim) + * + */ + __pyx_t_2 = ((__pyx_v_dst_ndim < __pyx_v_src_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1289 + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: + * broadcast_leading(&dst, dst_ndim, src_ndim) # <<<<<<<<<<<<<< + * + * cdef int ndim = max(src_ndim, dst_ndim) + */ + __pyx_memoryview_broadcast_leading((&__pyx_v_dst), __pyx_v_dst_ndim, __pyx_v_src_ndim); + + /* "View.MemoryView":1288 + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&dst, dst_ndim, src_ndim) + * + */ + } + __pyx_L3:; + + /* "View.MemoryView":1291 + * broadcast_leading(&dst, dst_ndim, src_ndim) + * + * cdef int ndim = max(src_ndim, dst_ndim) # <<<<<<<<<<<<<< + * + * for i in range(ndim): + */ + __pyx_t_3 = __pyx_v_dst_ndim; + __pyx_t_4 = __pyx_v_src_ndim; + if (((__pyx_t_3 > __pyx_t_4) != 0)) { + __pyx_t_5 = __pyx_t_3; + } else { + __pyx_t_5 = __pyx_t_4; + } + __pyx_v_ndim = __pyx_t_5; + + /* "View.MemoryView":1293 + * cdef int ndim = max(src_ndim, dst_ndim) + * + * for i in range(ndim): # <<<<<<<<<<<<<< + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: + */ + __pyx_t_5 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_5; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1294 + * + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< + * if src.shape[i] == 1: + * broadcasting = True + */ + __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) != (__pyx_v_dst.shape[__pyx_v_i])) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1295 + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: # <<<<<<<<<<<<<< + * broadcasting = True + * src.strides[i] = 0 + */ + __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) == 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1296 + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: + * broadcasting = True # <<<<<<<<<<<<<< + * src.strides[i] = 0 + * else: + */ + __pyx_v_broadcasting = 1; + + /* "View.MemoryView":1297 + * if src.shape[i] == 1: + * broadcasting = True + * src.strides[i] = 0 # <<<<<<<<<<<<<< + * else: + * _err_extents(i, dst.shape[i], src.shape[i]) + */ + (__pyx_v_src.strides[__pyx_v_i]) = 0; + + /* "View.MemoryView":1295 + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: # <<<<<<<<<<<<<< + * broadcasting = True + * src.strides[i] = 0 + */ + goto __pyx_L7; + } + + /* "View.MemoryView":1299 + * src.strides[i] = 0 + * else: + * _err_extents(i, dst.shape[i], src.shape[i]) # <<<<<<<<<<<<<< + * + * if src.suboffsets[i] >= 0: + */ + /*else*/ { + __pyx_t_6 = __pyx_memoryview_err_extents(__pyx_v_i, (__pyx_v_dst.shape[__pyx_v_i]), (__pyx_v_src.shape[__pyx_v_i])); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1299, __pyx_L1_error) + } + __pyx_L7:; + + /* "View.MemoryView":1294 + * + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< + * if src.shape[i] == 1: + * broadcasting = True + */ + } + + /* "View.MemoryView":1301 + * _err_extents(i, dst.shape[i], src.shape[i]) + * + * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + */ + __pyx_t_2 = (((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1302 + * + * if src.suboffsets[i] >= 0: + * _err_dim(ValueError, "Dimension %d is not direct", i) # <<<<<<<<<<<<<< + * + * if slices_overlap(&src, &dst, ndim, itemsize): + */ + __pyx_t_6 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Dimension %d is not direct"), __pyx_v_i); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1302, __pyx_L1_error) + + /* "View.MemoryView":1301 + * _err_extents(i, dst.shape[i], src.shape[i]) + * + * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + */ + } + } + + /* "View.MemoryView":1304 + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< + * + * if not slice_is_contig(src, order, ndim): + */ + __pyx_t_2 = (__pyx_slices_overlap((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1306 + * if slices_overlap(&src, &dst, ndim, itemsize): + * + * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< + * order = get_best_order(&dst, ndim) + * + */ + __pyx_t_2 = ((!(__pyx_memviewslice_is_contig(__pyx_v_src, __pyx_v_order, __pyx_v_ndim) != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1307 + * + * if not slice_is_contig(src, order, ndim): + * order = get_best_order(&dst, ndim) # <<<<<<<<<<<<<< + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) + */ + __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim); + + /* "View.MemoryView":1306 + * if slices_overlap(&src, &dst, ndim, itemsize): + * + * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< + * order = get_best_order(&dst, ndim) + * + */ + } + + /* "View.MemoryView":1309 + * order = get_best_order(&dst, ndim) + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) # <<<<<<<<<<<<<< + * src = tmp + * + */ + __pyx_t_7 = __pyx_memoryview_copy_data_to_temp((&__pyx_v_src), (&__pyx_v_tmp), __pyx_v_order, __pyx_v_ndim); if (unlikely(__pyx_t_7 == ((void *)NULL))) __PYX_ERR(1, 1309, __pyx_L1_error) + __pyx_v_tmpdata = __pyx_t_7; + + /* "View.MemoryView":1310 + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) + * src = tmp # <<<<<<<<<<<<<< + * + * if not broadcasting: + */ + __pyx_v_src = __pyx_v_tmp; + + /* "View.MemoryView":1304 + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< + * + * if not slice_is_contig(src, order, ndim): + */ + } + + /* "View.MemoryView":1312 + * src = tmp + * + * if not broadcasting: # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = ((!(__pyx_v_broadcasting != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1315 + * + * + * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): + */ + __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'C', __pyx_v_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1316 + * + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) # <<<<<<<<<<<<<< + * elif slice_is_contig(src, 'F', ndim): + * direct_copy = slice_is_contig(dst, 'F', ndim) + */ + __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'C', __pyx_v_ndim); + + /* "View.MemoryView":1315 + * + * + * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): + */ + goto __pyx_L12; + } + + /* "View.MemoryView":1317 + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + */ + __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'F', __pyx_v_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1318 + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): + * direct_copy = slice_is_contig(dst, 'F', ndim) # <<<<<<<<<<<<<< + * + * if direct_copy: + */ + __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'F', __pyx_v_ndim); + + /* "View.MemoryView":1317 + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + */ + } + __pyx_L12:; + + /* "View.MemoryView":1320 + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + * if direct_copy: # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + __pyx_t_2 = (__pyx_v_direct_copy != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1322 + * if direct_copy: + * + * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1323 + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, True) + * free(tmpdata) + */ + (void)(memcpy(__pyx_v_dst.data, __pyx_v_src.data, __pyx_memoryview_slice_get_size((&__pyx_v_src), __pyx_v_ndim))); + + /* "View.MemoryView":1324 + * refcount_copying(&dst, dtype_is_object, ndim, False) + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * free(tmpdata) + * return 0 + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1325 + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) + * free(tmpdata) # <<<<<<<<<<<<<< + * return 0 + * + */ + free(__pyx_v_tmpdata); + + /* "View.MemoryView":1326 + * refcount_copying(&dst, dtype_is_object, ndim, True) + * free(tmpdata) + * return 0 # <<<<<<<<<<<<<< + * + * if order == 'F' == get_best_order(&dst, ndim): + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":1320 + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + * if direct_copy: # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + } + + /* "View.MemoryView":1312 + * src = tmp + * + * if not broadcasting: # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":1328 + * return 0 + * + * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = (__pyx_v_order == 'F'); + if (__pyx_t_2) { + __pyx_t_2 = ('F' == __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim)); + } + __pyx_t_8 = (__pyx_t_2 != 0); + if (__pyx_t_8) { + + /* "View.MemoryView":1331 + * + * + * transpose_memslice(&src) # <<<<<<<<<<<<<< + * transpose_memslice(&dst) + * + */ + __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_src)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1331, __pyx_L1_error) + + /* "View.MemoryView":1332 + * + * transpose_memslice(&src) + * transpose_memslice(&dst) # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_dst)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1332, __pyx_L1_error) + + /* "View.MemoryView":1328 + * return 0 + * + * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":1334 + * transpose_memslice(&dst) + * + * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * copy_strided_to_strided(&src, &dst, ndim, itemsize) + * refcount_copying(&dst, dtype_is_object, ndim, True) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1335 + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + * copy_strided_to_strided(&src, &dst, ndim, itemsize) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, True) + * + */ + copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); + + /* "View.MemoryView":1336 + * refcount_copying(&dst, dtype_is_object, ndim, False) + * copy_strided_to_strided(&src, &dst, ndim, itemsize) + * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * + * free(tmpdata) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1338 + * refcount_copying(&dst, dtype_is_object, ndim, True) + * + * free(tmpdata) # <<<<<<<<<<<<<< + * return 0 + * + */ + free(__pyx_v_tmpdata); + + /* "View.MemoryView":1339 + * + * free(tmpdata) + * return 0 # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_broadcast_leading') + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":1270 + * + * @cname('__pyx_memoryview_copy_contents') + * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice dst, + * int src_ndim, int dst_ndim, + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.memoryview_copy_contents", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1342 + * + * @cname('__pyx_memoryview_broadcast_leading') + * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< + * int ndim, + * int ndim_other) nogil: + */ + +static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim, int __pyx_v_ndim_other) { + int __pyx_v_i; + int __pyx_v_offset; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + + /* "View.MemoryView":1346 + * int ndim_other) nogil: + * cdef int i + * cdef int offset = ndim_other - ndim # <<<<<<<<<<<<<< + * + * for i in range(ndim - 1, -1, -1): + */ + __pyx_v_offset = (__pyx_v_ndim_other - __pyx_v_ndim); + + /* "View.MemoryView":1348 + * cdef int offset = ndim_other - ndim + * + * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = mslice.strides[i] + */ + for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { + __pyx_v_i = __pyx_t_1; + + /* "View.MemoryView":1349 + * + * for i in range(ndim - 1, -1, -1): + * mslice.shape[i + offset] = mslice.shape[i] # <<<<<<<<<<<<<< + * mslice.strides[i + offset] = mslice.strides[i] + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] + */ + (__pyx_v_mslice->shape[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->shape[__pyx_v_i]); + + /* "View.MemoryView":1350 + * for i in range(ndim - 1, -1, -1): + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = mslice.strides[i] # <<<<<<<<<<<<<< + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] + * + */ + (__pyx_v_mslice->strides[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->strides[__pyx_v_i]); + + /* "View.MemoryView":1351 + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = mslice.strides[i] + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] # <<<<<<<<<<<<<< + * + * for i in range(offset): + */ + (__pyx_v_mslice->suboffsets[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->suboffsets[__pyx_v_i]); + } + + /* "View.MemoryView":1353 + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] + * + * for i in range(offset): # <<<<<<<<<<<<<< + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] + */ + __pyx_t_1 = __pyx_v_offset; + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_i = __pyx_t_3; + + /* "View.MemoryView":1354 + * + * for i in range(offset): + * mslice.shape[i] = 1 # <<<<<<<<<<<<<< + * mslice.strides[i] = mslice.strides[0] + * mslice.suboffsets[i] = -1 + */ + (__pyx_v_mslice->shape[__pyx_v_i]) = 1; + + /* "View.MemoryView":1355 + * for i in range(offset): + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] # <<<<<<<<<<<<<< + * mslice.suboffsets[i] = -1 + * + */ + (__pyx_v_mslice->strides[__pyx_v_i]) = (__pyx_v_mslice->strides[0]); + + /* "View.MemoryView":1356 + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] + * mslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< + * + * + */ + (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L; + } + + /* "View.MemoryView":1342 + * + * @cname('__pyx_memoryview_broadcast_leading') + * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< + * int ndim, + * int ndim_other) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1364 + * + * @cname('__pyx_memoryview_refcount_copying') + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< + * int ndim, bint inc) nogil: + * + */ + +static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_dtype_is_object, int __pyx_v_ndim, int __pyx_v_inc) { + int __pyx_t_1; + + /* "View.MemoryView":1368 + * + * + * if dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, + * dst.strides, ndim, inc) + */ + __pyx_t_1 = (__pyx_v_dtype_is_object != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1369 + * + * if dtype_is_object: + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, # <<<<<<<<<<<<<< + * dst.strides, ndim, inc) + * + */ + __pyx_memoryview_refcount_objects_in_slice_with_gil(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_inc); + + /* "View.MemoryView":1368 + * + * + * if dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, + * dst.strides, ndim, inc) + */ + } + + /* "View.MemoryView":1364 + * + * @cname('__pyx_memoryview_refcount_copying') + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< + * int ndim, bint inc) nogil: + * + */ + + /* function exit code */ +} + +/* "View.MemoryView":1373 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') + * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * bint inc) with gil: + */ + +static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { + __Pyx_RefNannyDeclarations + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("refcount_objects_in_slice_with_gil", 0); + + /* "View.MemoryView":1376 + * Py_ssize_t *strides, int ndim, + * bint inc) with gil: + * refcount_objects_in_slice(data, shape, strides, ndim, inc) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') + */ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, __pyx_v_shape, __pyx_v_strides, __pyx_v_ndim, __pyx_v_inc); + + /* "View.MemoryView":1373 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') + * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * bint inc) with gil: + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif +} + +/* "View.MemoryView":1379 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') + * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, bint inc): + * cdef Py_ssize_t i + */ + +static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + __Pyx_RefNannySetupContext("refcount_objects_in_slice", 0); + + /* "View.MemoryView":1383 + * cdef Py_ssize_t i + * + * for i in range(shape[0]): # <<<<<<<<<<<<<< + * if ndim == 1: + * if inc: + */ + __pyx_t_1 = (__pyx_v_shape[0]); + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_i = __pyx_t_3; + + /* "View.MemoryView":1384 + * + * for i in range(shape[0]): + * if ndim == 1: # <<<<<<<<<<<<<< + * if inc: + * Py_INCREF(( data)[0]) + */ + __pyx_t_4 = ((__pyx_v_ndim == 1) != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":1385 + * for i in range(shape[0]): + * if ndim == 1: + * if inc: # <<<<<<<<<<<<<< + * Py_INCREF(( data)[0]) + * else: + */ + __pyx_t_4 = (__pyx_v_inc != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":1386 + * if ndim == 1: + * if inc: + * Py_INCREF(( data)[0]) # <<<<<<<<<<<<<< + * else: + * Py_DECREF(( data)[0]) + */ + Py_INCREF((((PyObject **)__pyx_v_data)[0])); + + /* "View.MemoryView":1385 + * for i in range(shape[0]): + * if ndim == 1: + * if inc: # <<<<<<<<<<<<<< + * Py_INCREF(( data)[0]) + * else: + */ + goto __pyx_L6; + } + + /* "View.MemoryView":1388 + * Py_INCREF(( data)[0]) + * else: + * Py_DECREF(( data)[0]) # <<<<<<<<<<<<<< + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, + */ + /*else*/ { + Py_DECREF((((PyObject **)__pyx_v_data)[0])); + } + __pyx_L6:; + + /* "View.MemoryView":1384 + * + * for i in range(shape[0]): + * if ndim == 1: # <<<<<<<<<<<<<< + * if inc: + * Py_INCREF(( data)[0]) + */ + goto __pyx_L5; + } + + /* "View.MemoryView":1390 + * Py_DECREF(( data)[0]) + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< + * ndim - 1, inc) + * + */ + /*else*/ { + + /* "View.MemoryView":1391 + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, + * ndim - 1, inc) # <<<<<<<<<<<<<< + * + * data += strides[0] + */ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_inc); + } + __pyx_L5:; + + /* "View.MemoryView":1393 + * ndim - 1, inc) + * + * data += strides[0] # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_data = (__pyx_v_data + (__pyx_v_strides[0])); + } + + /* "View.MemoryView":1379 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') + * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, bint inc): + * cdef Py_ssize_t i + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":1399 + * + * @cname('__pyx_memoryview_slice_assign_scalar') + * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< + * size_t itemsize, void *item, + * bint dtype_is_object) nogil: + */ + +static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item, int __pyx_v_dtype_is_object) { + + /* "View.MemoryView":1402 + * size_t itemsize, void *item, + * bint dtype_is_object) nogil: + * refcount_copying(dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, + * itemsize, item) + */ + __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1403 + * bint dtype_is_object) nogil: + * refcount_copying(dst, dtype_is_object, ndim, False) + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, # <<<<<<<<<<<<<< + * itemsize, item) + * refcount_copying(dst, dtype_is_object, ndim, True) + */ + __pyx_memoryview__slice_assign_scalar(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_itemsize, __pyx_v_item); + + /* "View.MemoryView":1405 + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, + * itemsize, item) + * refcount_copying(dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * + * + */ + __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1399 + * + * @cname('__pyx_memoryview_slice_assign_scalar') + * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< + * size_t itemsize, void *item, + * bint dtype_is_object) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1409 + * + * @cname('__pyx_memoryview__slice_assign_scalar') + * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * size_t itemsize, void *item) nogil: + */ + +static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + Py_ssize_t __pyx_v_stride; + Py_ssize_t __pyx_v_extent; + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + + /* "View.MemoryView":1413 + * size_t itemsize, void *item) nogil: + * cdef Py_ssize_t i + * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t extent = shape[0] + * + */ + __pyx_v_stride = (__pyx_v_strides[0]); + + /* "View.MemoryView":1414 + * cdef Py_ssize_t i + * cdef Py_ssize_t stride = strides[0] + * cdef Py_ssize_t extent = shape[0] # <<<<<<<<<<<<<< + * + * if ndim == 1: + */ + __pyx_v_extent = (__pyx_v_shape[0]); + + /* "View.MemoryView":1416 + * cdef Py_ssize_t extent = shape[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * for i in range(extent): + * memcpy(data, item, itemsize) + */ + __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1417 + * + * if ndim == 1: + * for i in range(extent): # <<<<<<<<<<<<<< + * memcpy(data, item, itemsize) + * data += stride + */ + __pyx_t_2 = __pyx_v_extent; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1418 + * if ndim == 1: + * for i in range(extent): + * memcpy(data, item, itemsize) # <<<<<<<<<<<<<< + * data += stride + * else: + */ + (void)(memcpy(__pyx_v_data, __pyx_v_item, __pyx_v_itemsize)); + + /* "View.MemoryView":1419 + * for i in range(extent): + * memcpy(data, item, itemsize) + * data += stride # <<<<<<<<<<<<<< + * else: + * for i in range(extent): + */ + __pyx_v_data = (__pyx_v_data + __pyx_v_stride); + } + + /* "View.MemoryView":1416 + * cdef Py_ssize_t extent = shape[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * for i in range(extent): + * memcpy(data, item, itemsize) + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1421 + * data += stride + * else: + * for i in range(extent): # <<<<<<<<<<<<<< + * _slice_assign_scalar(data, shape + 1, strides + 1, + * ndim - 1, itemsize, item) + */ + /*else*/ { + __pyx_t_2 = __pyx_v_extent; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1422 + * else: + * for i in range(extent): + * _slice_assign_scalar(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< + * ndim - 1, itemsize, item) + * data += stride + */ + __pyx_memoryview__slice_assign_scalar(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize, __pyx_v_item); + + /* "View.MemoryView":1424 + * _slice_assign_scalar(data, shape + 1, strides + 1, + * ndim - 1, itemsize, item) + * data += stride # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_data = (__pyx_v_data + __pyx_v_stride); + } + } + __pyx_L3:; + + /* "View.MemoryView":1409 + * + * @cname('__pyx_memoryview__slice_assign_scalar') + * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * size_t itemsize, void *item) nogil: + */ + + /* function exit code */ +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum = {"__pyx_unpickle_Enum", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Enum") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 0); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__19, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError); + __pyx_t_4 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) # <<<<<<<<<<<<<< + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_INCREF(__pyx_v___pyx_PickleError); + __pyx_t_1 = __pyx_v___pyx_PickleError; __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_MemviewEnum_type), __pyx_n_s_new); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v___pyx_type); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result = __pyx_t_4; + __pyx_t_4 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_3 = (__pyx_v___pyx_state != Py_None); + __pyx_t_2 = (__pyx_t_3 != 0); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||((void)PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 9, __pyx_L1_error) + __pyx_t_4 = __pyx_unpickle_Enum__set_state(((struct __pyx_MemviewEnum_obj *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 0); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->name); + __Pyx_DECREF(__pyx_v___pyx_result->name); + __pyx_v___pyx_result->name = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 13, __pyx_L1_error) + } + __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_4 = ((__pyx_t_3 > 1) != 0); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_4 != 0); + __pyx_t_2 = __pyx_t_5; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 14, __pyx_L1_error) + } + __pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static struct __pyx_vtabstruct_array __pyx_vtable_array; + +static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_array_obj *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_array_obj *)o); + p->__pyx_vtab = __pyx_vtabptr_array; + p->mode = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_format = ((PyObject*)Py_None); Py_INCREF(Py_None); + if (unlikely(__pyx_array___cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_array(PyObject *o) { + struct __pyx_array_obj *p = (struct __pyx_array_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_array___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->mode); + Py_CLEAR(p->_format); + (*Py_TYPE(o)->tp_free)(o); +} +static PyObject *__pyx_sq_item_array(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_array(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_array___setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyObject *__pyx_tp_getattro_array(PyObject *o, PyObject *n) { + PyObject *v = __Pyx_PyObject_GenericGetAttr(o, n); + if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + v = __pyx_array___getattr__(o, n); + } + return v; +} + +static PyObject *__pyx_getprop___pyx_array_memview(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(o); +} + +static PyMethodDef __pyx_methods_array[] = { + {"__getattr__", (PyCFunction)__pyx_array___getattr__, METH_O|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_array_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_array_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_array[] = { + {(char *)"memview", __pyx_getprop___pyx_array_memview, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_array = { + __pyx_array___len__, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_array, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_array = { + __pyx_array___len__, /*mp_length*/ + __pyx_array___getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_array, /*mp_ass_subscript*/ +}; + +static PyBufferProcs __pyx_tp_as_buffer_array = { + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getreadbuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getwritebuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getsegcount*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getcharbuffer*/ + #endif + __pyx_array_getbuffer, /*bf_getbuffer*/ + 0, /*bf_releasebuffer*/ +}; + +static PyTypeObject __pyx_type___pyx_array = { + PyVarObject_HEAD_INIT(0, 0) + "zoo.board_games.gomoku.envs.legal_actions_cython.array", /*tp_name*/ + sizeof(struct __pyx_array_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_array, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_array, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_array, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + __pyx_tp_getattro_array, /*tp_getattro*/ + 0, /*tp_setattro*/ + &__pyx_tp_as_buffer_array, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_array, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_array, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_array, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + 0, /*tp_pypy_flags*/ + #endif +}; + +static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_MemviewEnum_obj *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_MemviewEnum_obj *)o); + p->name = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_Enum(PyObject *o) { + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->name); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_Enum(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + if (p->name) { + e = (*v)(p->name, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_Enum(PyObject *o) { + PyObject* tmp; + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + tmp = ((PyObject*)p->name); + p->name = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyMethodDef __pyx_methods_Enum[] = { + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type___pyx_MemviewEnum = { + PyVarObject_HEAD_INIT(0, 0) + "zoo.board_games.gomoku.envs.legal_actions_cython.Enum", /*tp_name*/ + sizeof(struct __pyx_MemviewEnum_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_Enum, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_MemviewEnum___repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_Enum, /*tp_traverse*/ + __pyx_tp_clear_Enum, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_Enum, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_MemviewEnum___init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_Enum, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + 0, /*tp_pypy_flags*/ + #endif +}; +static struct __pyx_vtabstruct_memoryview __pyx_vtable_memoryview; + +static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_memoryview_obj *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_memoryview_obj *)o); + p->__pyx_vtab = __pyx_vtabptr_memoryview; + p->obj = Py_None; Py_INCREF(Py_None); + p->_size = Py_None; Py_INCREF(Py_None); + p->_array_interface = Py_None; Py_INCREF(Py_None); + p->view.obj = NULL; + if (unlikely(__pyx_memoryview___cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_memoryview(PyObject *o) { + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_memoryview___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->obj); + Py_CLEAR(p->_size); + Py_CLEAR(p->_array_interface); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_memoryview(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + if (p->obj) { + e = (*v)(p->obj, a); if (e) return e; + } + if (p->_size) { + e = (*v)(p->_size, a); if (e) return e; + } + if (p->_array_interface) { + e = (*v)(p->_array_interface, a); if (e) return e; + } + if (p->view.obj) { + e = (*v)(p->view.obj, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_memoryview(PyObject *o) { + PyObject* tmp; + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + tmp = ((PyObject*)p->obj); + p->obj = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_size); + p->_size = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_array_interface); + p->_array_interface = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + Py_CLEAR(p->view.obj); + return 0; +} +static PyObject *__pyx_sq_item_memoryview(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_memoryview(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_memoryview___setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyObject *__pyx_getprop___pyx_memoryview_T(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_base(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_shape(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_strides(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_suboffsets(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_ndim(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_itemsize(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_nbytes(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_size(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(o); +} + +static PyMethodDef __pyx_methods_memoryview[] = { + {"is_c_contig", (PyCFunction)__pyx_memoryview_is_c_contig, METH_NOARGS, 0}, + {"is_f_contig", (PyCFunction)__pyx_memoryview_is_f_contig, METH_NOARGS, 0}, + {"copy", (PyCFunction)__pyx_memoryview_copy, METH_NOARGS, 0}, + {"copy_fortran", (PyCFunction)__pyx_memoryview_copy_fortran, METH_NOARGS, 0}, + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_memoryview[] = { + {(char *)"T", __pyx_getprop___pyx_memoryview_T, 0, (char *)0, 0}, + {(char *)"base", __pyx_getprop___pyx_memoryview_base, 0, (char *)0, 0}, + {(char *)"shape", __pyx_getprop___pyx_memoryview_shape, 0, (char *)0, 0}, + {(char *)"strides", __pyx_getprop___pyx_memoryview_strides, 0, (char *)0, 0}, + {(char *)"suboffsets", __pyx_getprop___pyx_memoryview_suboffsets, 0, (char *)0, 0}, + {(char *)"ndim", __pyx_getprop___pyx_memoryview_ndim, 0, (char *)0, 0}, + {(char *)"itemsize", __pyx_getprop___pyx_memoryview_itemsize, 0, (char *)0, 0}, + {(char *)"nbytes", __pyx_getprop___pyx_memoryview_nbytes, 0, (char *)0, 0}, + {(char *)"size", __pyx_getprop___pyx_memoryview_size, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_memoryview = { + __pyx_memoryview___len__, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_memoryview, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_memoryview = { + __pyx_memoryview___len__, /*mp_length*/ + __pyx_memoryview___getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_memoryview, /*mp_ass_subscript*/ +}; + +static PyBufferProcs __pyx_tp_as_buffer_memoryview = { + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getreadbuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getwritebuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getsegcount*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getcharbuffer*/ + #endif + __pyx_memoryview_getbuffer, /*bf_getbuffer*/ + 0, /*bf_releasebuffer*/ +}; + +static PyTypeObject __pyx_type___pyx_memoryview = { + PyVarObject_HEAD_INIT(0, 0) + "zoo.board_games.gomoku.envs.legal_actions_cython.memoryview", /*tp_name*/ + sizeof(struct __pyx_memoryview_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_memoryview, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_memoryview___repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_memoryview, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_memoryview, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + __pyx_memoryview___str__, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + &__pyx_tp_as_buffer_memoryview, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_memoryview, /*tp_traverse*/ + __pyx_tp_clear_memoryview, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_memoryview, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_memoryview, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_memoryview, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + 0, /*tp_pypy_flags*/ + #endif +}; +static struct __pyx_vtabstruct__memoryviewslice __pyx_vtable__memoryviewslice; + +static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_memoryviewslice_obj *p; + PyObject *o = __pyx_tp_new_memoryview(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_memoryviewslice_obj *)o); + p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_memoryview*)__pyx_vtabptr__memoryviewslice; + p->from_object = Py_None; Py_INCREF(Py_None); + p->from_slice.memview = NULL; + return o; +} + +static void __pyx_tp_dealloc__memoryviewslice(PyObject *o) { + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_memoryviewslice___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->from_object); + PyObject_GC_Track(o); + __pyx_tp_dealloc_memoryview(o); +} + +static int __pyx_tp_traverse__memoryviewslice(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + e = __pyx_tp_traverse_memoryview(o, v, a); if (e) return e; + if (p->from_object) { + e = (*v)(p->from_object, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear__memoryviewslice(PyObject *o) { + PyObject* tmp; + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + __pyx_tp_clear_memoryview(o); + tmp = ((PyObject*)p->from_object); + p->from_object = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + __PYX_XDEC_MEMVIEW(&p->from_slice, 1); + return 0; +} + +static PyObject *__pyx_getprop___pyx_memoryviewslice_base(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(o); +} + +static PyMethodDef __pyx_methods__memoryviewslice[] = { + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets__memoryviewslice[] = { + {(char *)"base", __pyx_getprop___pyx_memoryviewslice_base, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type___pyx_memoryviewslice = { + PyVarObject_HEAD_INIT(0, 0) + "zoo.board_games.gomoku.envs.legal_actions_cython._memoryviewslice", /*tp_name*/ + sizeof(struct __pyx_memoryviewslice_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc__memoryviewslice, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + #if CYTHON_COMPILING_IN_PYPY + __pyx_memoryview___repr__, /*tp_repr*/ + #else + 0, /*tp_repr*/ + #endif + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + #if CYTHON_COMPILING_IN_PYPY + __pyx_memoryview___str__, /*tp_str*/ + #else + 0, /*tp_str*/ + #endif + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + "Internal class for passing memoryview slices to Python", /*tp_doc*/ + __pyx_tp_traverse__memoryviewslice, /*tp_traverse*/ + __pyx_tp_clear__memoryviewslice, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods__memoryviewslice, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets__memoryviewslice, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new__memoryviewslice, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + 0, /*tp_pypy_flags*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {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_legal_actions_cython(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_legal_actions_cython}, + {0, NULL} +}; +#endif + +static struct PyModuleDef __pyx_moduledef = { + PyModuleDef_HEAD_INIT, + "legal_actions_cython", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_ASCII, __pyx_k_ASCII, sizeof(__pyx_k_ASCII), 0, 0, 1, 1}, + {&__pyx_kp_s_Buffer_view_does_not_expose_stri, __pyx_k_Buffer_view_does_not_expose_stri, sizeof(__pyx_k_Buffer_view_does_not_expose_stri), 0, 0, 1, 0}, + {&__pyx_kp_s_Can_only_create_a_buffer_that_is, __pyx_k_Can_only_create_a_buffer_that_is, sizeof(__pyx_k_Can_only_create_a_buffer_that_is), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_assign_to_read_only_memor, __pyx_k_Cannot_assign_to_read_only_memor, sizeof(__pyx_k_Cannot_assign_to_read_only_memor), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_create_writable_memory_vi, __pyx_k_Cannot_create_writable_memory_vi, sizeof(__pyx_k_Cannot_create_writable_memory_vi), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_index_with_type_s, __pyx_k_Cannot_index_with_type_s, sizeof(__pyx_k_Cannot_index_with_type_s), 0, 0, 1, 0}, + {&__pyx_n_s_Ellipsis, __pyx_k_Ellipsis, sizeof(__pyx_k_Ellipsis), 0, 0, 1, 1}, + {&__pyx_kp_s_Empty_shape_tuple_for_cython_arr, __pyx_k_Empty_shape_tuple_for_cython_arr, sizeof(__pyx_k_Empty_shape_tuple_for_cython_arr), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 0, 1, 0}, + {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1}, + {&__pyx_kp_s_Indirect_dimensions_not_supporte, __pyx_k_Indirect_dimensions_not_supporte, sizeof(__pyx_k_Indirect_dimensions_not_supporte), 0, 0, 1, 0}, + {&__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_k_Invalid_mode_expected_c_or_fortr, sizeof(__pyx_k_Invalid_mode_expected_c_or_fortr), 0, 0, 1, 0}, + {&__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_k_Invalid_shape_in_axis_d_d, sizeof(__pyx_k_Invalid_shape_in_axis_d_d), 0, 0, 1, 0}, + {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, + {&__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_k_MemoryView_of_r_at_0x_x, sizeof(__pyx_k_MemoryView_of_r_at_0x_x), 0, 0, 1, 0}, + {&__pyx_kp_s_MemoryView_of_r_object, __pyx_k_MemoryView_of_r_object, sizeof(__pyx_k_MemoryView_of_r_object), 0, 0, 1, 0}, + {&__pyx_n_b_O, __pyx_k_O, sizeof(__pyx_k_O), 0, 0, 0, 1}, + {&__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_k_Out_of_bounds_on_buffer_access_a, sizeof(__pyx_k_Out_of_bounds_on_buffer_access_a), 0, 0, 1, 0}, + {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_kp_s_Unable_to_convert_item_to_object, __pyx_k_Unable_to_convert_item_to_object, sizeof(__pyx_k_Unable_to_convert_item_to_object), 0, 0, 1, 0}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_View_MemoryView, __pyx_k_View_MemoryView, sizeof(__pyx_k_View_MemoryView), 0, 0, 1, 1}, + {&__pyx_n_s_allocate_buffer, __pyx_k_allocate_buffer, sizeof(__pyx_k_allocate_buffer), 0, 0, 1, 1}, + {&__pyx_n_s_base, __pyx_k_base, sizeof(__pyx_k_base), 0, 0, 1, 1}, + {&__pyx_n_s_board, __pyx_k_board, sizeof(__pyx_k_board), 0, 0, 1, 1}, + {&__pyx_n_s_board_size, __pyx_k_board_size, sizeof(__pyx_k_board_size), 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_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, + {&__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_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1}, + {&__pyx_n_s_legal_actions, __pyx_k_legal_actions, sizeof(__pyx_k_legal_actions), 0, 0, 1, 1}, + {&__pyx_n_s_legal_actions_cython, __pyx_k_legal_actions_cython, sizeof(__pyx_k_legal_actions_cython), 0, 0, 1, 1}, + {&__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_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_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_kp_s_zoo_board_games_gomoku_envs_lega, __pyx_k_zoo_board_games_gomoku_envs_lega, sizeof(__pyx_k_zoo_board_games_gomoku_envs_lega), 0, 0, 1, 0}, + {&__pyx_n_s_zoo_board_games_gomoku_envs_lega_2, __pyx_k_zoo_board_games_gomoku_envs_lega_2, sizeof(__pyx_k_zoo_board_games_gomoku_envs_lega_2), 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, 12, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 134, __pyx_L1_error) + __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 149, __pyx_L1_error) + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 152, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) + __pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_n_s_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(1, 406, __pyx_L1_error) + __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(1, 615, __pyx_L1_error) + __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 834, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "View.MemoryView":134 + * + * if not self.ndim: + * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< + * + * if itemsize <= 0: + */ + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_Empty_shape_tuple_for_cython_arr); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "View.MemoryView":137 + * + * if itemsize <= 0: + * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< + * + * if not isinstance(format, bytes): + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_itemsize_0_for_cython_array); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "View.MemoryView":149 + * + * if not self._shape: + * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_shape_and_str); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "View.MemoryView":177 + * self.data = malloc(self.len) + * if not self.data: + * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< + * + * if self.dtype_is_object: + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_array_data); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "View.MemoryView":193 + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") # <<<<<<<<<<<<<< + * info.buf = self.data + * info.len = self.len + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_Can_only_create_a_buffer_that_is); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "(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__6 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + + /* "(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__7 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + + /* "View.MemoryView":420 + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< + * + * have_slices, index = _unellipsify(index, self.view.ndim) + */ + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_Cannot_assign_to_read_only_memor); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "View.MemoryView":497 + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< + * else: + * if len(self.view.format) == 1: + */ + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_Unable_to_convert_item_to_object); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + + /* "View.MemoryView":522 + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<< + * + * if flags & PyBUF_ND: + */ + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_Cannot_create_writable_memory_vi); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + + /* "View.MemoryView":572 + * if self.view.strides == NULL: + * + * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) + */ + __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_Buffer_view_does_not_expose_stri); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + /* "View.MemoryView":579 + * def suboffsets(self): + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) + */ + __pyx_tuple__12 = PyTuple_New(1); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_INCREF(__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_int_neg_1); + PyTuple_SET_ITEM(__pyx_tuple__12, 0, __pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "(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__13 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + + /* "(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__14 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); + + /* "View.MemoryView":684 + * if item is Ellipsis: + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<< + * seen_ellipsis = True + * else: + */ + __pyx_slice__15 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__15)) __PYX_ERR(1, 684, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__15); + __Pyx_GIVEREF(__pyx_slice__15); + + /* "View.MemoryView":705 + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + * raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_Indirect_dimensions_not_supporte); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(1, 705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); + + /* "(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__17 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__17); + __Pyx_GIVEREF(__pyx_tuple__17); + + /* "(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__18 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__18); + __Pyx_GIVEREF(__pyx_tuple__18); + __pyx_tuple__19 = PyTuple_Pack(3, __pyx_int_184977713, __pyx_int_136983863, __pyx_int_112105877); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__19); + __Pyx_GIVEREF(__pyx_tuple__19); + + /* "zoo/board_games/gomoku/envs/legal_actions_cython.pyx":6 + * @cython.boundscheck(False) # Disable bounds checking for performance + * @cython.wraparound(False) # Disable negative indexing for performance + * def legal_actions_cython(int board_size, int32_t[:, :] board): # <<<<<<<<<<<<<< + * # Use a Python list to store possible legal actions + * cdef list legal_actions = [] + */ + __pyx_tuple__20 = PyTuple_Pack(5, __pyx_n_s_board_size, __pyx_n_s_board, __pyx_n_s_legal_actions, __pyx_n_s_i, __pyx_n_s_j); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__20); + __Pyx_GIVEREF(__pyx_tuple__20); + __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(2, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_zoo_board_games_gomoku_envs_lega, __pyx_n_s_legal_actions_cython, 6, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 6, __pyx_L1_error) + + /* "View.MemoryView":287 + * return self.name + * + * cdef generic = Enum("") # <<<<<<<<<<<<<< + * cdef strided = Enum("") # default + * cdef indirect = Enum("") + */ + __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(1, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__22); + __Pyx_GIVEREF(__pyx_tuple__22); + + /* "View.MemoryView":288 + * + * cdef generic = Enum("") + * cdef strided = Enum("") # default # <<<<<<<<<<<<<< + * cdef indirect = Enum("") + * + */ + __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(1, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__23); + __Pyx_GIVEREF(__pyx_tuple__23); + + /* "View.MemoryView":289 + * cdef generic = Enum("") + * cdef strided = Enum("") # default + * cdef indirect = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(1, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__24); + __Pyx_GIVEREF(__pyx_tuple__24); + + /* "View.MemoryView":292 + * + * + * cdef contiguous = Enum("") # <<<<<<<<<<<<<< + * cdef indirect_contiguous = Enum("") + * + */ + __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(1, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__25); + __Pyx_GIVEREF(__pyx_tuple__25); + + /* "View.MemoryView":293 + * + * cdef contiguous = Enum("") + * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(1, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__26); + __Pyx_GIVEREF(__pyx_tuple__26); + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + __pyx_tuple__27 = 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__27)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__27); + __Pyx_GIVEREF(__pyx_tuple__27); + __pyx_codeobj__28 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__27, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__28)) __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) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_112105877 = PyInt_FromLong(112105877L); if (unlikely(!__pyx_int_112105877)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_136983863 = PyInt_FromLong(136983863L); if (unlikely(!__pyx_int_136983863)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_184977713 = PyInt_FromLong(184977713L); if (unlikely(!__pyx_int_184977713)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ + +static int __Pyx_modinit_global_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + generic = Py_None; Py_INCREF(Py_None); + strided = Py_None; Py_INCREF(Py_None); + indirect = Py_None; Py_INCREF(Py_None); + contiguous = Py_None; Py_INCREF(Py_None); + indirect_contiguous = Py_None; Py_INCREF(Py_None); + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + __pyx_vtabptr_array = &__pyx_vtable_array; + __pyx_vtable_array.get_memview = (PyObject *(*)(struct __pyx_array_obj *))__pyx_array_get_memview; + if (PyType_Ready(&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_array.tp_print = 0; + #endif + if (__Pyx_SetVtable(__pyx_type___pyx_array.tp_dict, __pyx_vtabptr_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) + __pyx_array_type = &__pyx_type___pyx_array; + if (PyType_Ready(&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 280, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_MemviewEnum.tp_print = 0; + #endif + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_MemviewEnum.tp_dictoffset && __pyx_type___pyx_MemviewEnum.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type___pyx_MemviewEnum.tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 280, __pyx_L1_error) + __pyx_MemviewEnum_type = &__pyx_type___pyx_MemviewEnum; + __pyx_vtabptr_memoryview = &__pyx_vtable_memoryview; + __pyx_vtable_memoryview.get_item_pointer = (char *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_get_item_pointer; + __pyx_vtable_memoryview.is_slice = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_is_slice; + __pyx_vtable_memoryview.setitem_slice_assignment = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_slice_assignment; + __pyx_vtable_memoryview.setitem_slice_assign_scalar = (PyObject *(*)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_setitem_slice_assign_scalar; + __pyx_vtable_memoryview.setitem_indexed = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_indexed; + __pyx_vtable_memoryview.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryview_convert_item_to_object; + __pyx_vtable_memoryview.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryview_assign_item_from_object; + if (PyType_Ready(&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_memoryview.tp_print = 0; + #endif + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryview.tp_dictoffset && __pyx_type___pyx_memoryview.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type___pyx_memoryview.tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + if (__Pyx_SetVtable(__pyx_type___pyx_memoryview.tp_dict, __pyx_vtabptr_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) + __pyx_memoryview_type = &__pyx_type___pyx_memoryview; + __pyx_vtabptr__memoryviewslice = &__pyx_vtable__memoryviewslice; + __pyx_vtable__memoryviewslice.__pyx_base = *__pyx_vtabptr_memoryview; + __pyx_vtable__memoryviewslice.__pyx_base.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryviewslice_convert_item_to_object; + __pyx_vtable__memoryviewslice.__pyx_base.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryviewslice_assign_item_from_object; + __pyx_type___pyx_memoryviewslice.tp_base = __pyx_memoryview_type; + if (PyType_Ready(&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_memoryviewslice.tp_print = 0; + #endif + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryviewslice.tp_dictoffset && __pyx_type___pyx_memoryviewslice.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type___pyx_memoryviewslice.tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + if (__Pyx_SetVtable(__pyx_type___pyx_memoryviewslice.tp_dict, __pyx_vtabptr__memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) + __pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyObject * +#endif +#endif + + +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initlegal_actions_cython(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initlegal_actions_cython(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_legal_actions_cython(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_legal_actions_cython(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_legal_actions_cython(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 'legal_actions_cython' 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_legal_actions_cython(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + PyEval_InitThreads(); + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("legal_actions_cython", __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_zoo__board_games__gomoku__envs__legal_actions_cython) { + 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, "zoo.board_games.gomoku.envs.legal_actions_cython")) { + if (unlikely(PyDict_SetItemString(modules, "zoo.board_games.gomoku.envs.legal_actions_cython", __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 + + /* "zoo/board_games/gomoku/envs/legal_actions_cython.pyx":6 + * @cython.boundscheck(False) # Disable bounds checking for performance + * @cython.wraparound(False) # Disable negative indexing for performance + * def legal_actions_cython(int board_size, int32_t[:, :] board): # <<<<<<<<<<<<<< + * # Use a Python list to store possible legal actions + * cdef list legal_actions = [] + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_3zoo_11board_games_6gomoku_4envs_20legal_actions_cython_1legal_actions_cython, NULL, __pyx_n_s_zoo_board_games_gomoku_envs_lega_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_legal_actions_cython, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "zoo/board_games/gomoku/envs/legal_actions_cython.pyx":1 + * from libc.stdint cimport int32_t # <<<<<<<<<<<<<< + * import cython + * + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":210 + * info.obj = self + * + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * def __dealloc__(array self): + */ + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_array_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_array_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 210, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_array_type); + + /* "View.MemoryView":287 + * return self.name + * + * cdef generic = Enum("") # <<<<<<<<<<<<<< + * cdef strided = Enum("") # default + * cdef indirect = Enum("") + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(generic); + __Pyx_DECREF_SET(generic, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":288 + * + * cdef generic = Enum("") + * cdef strided = Enum("") # default # <<<<<<<<<<<<<< + * cdef indirect = Enum("") + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(strided); + __Pyx_DECREF_SET(strided, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":289 + * cdef generic = Enum("") + * cdef strided = Enum("") # default + * cdef indirect = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(indirect); + __Pyx_DECREF_SET(indirect, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":292 + * + * + * cdef contiguous = Enum("") # <<<<<<<<<<<<<< + * cdef indirect_contiguous = Enum("") + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(contiguous); + __Pyx_DECREF_SET(contiguous, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":293 + * + * cdef contiguous = Enum("") + * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(indirect_contiguous); + __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":317 + * + * DEF THREAD_LOCKS_PREALLOCATED = 8 + * cdef int __pyx_memoryview_thread_locks_used = 0 # <<<<<<<<<<<<<< + * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ + * PyThread_allocate_lock(), + */ + __pyx_memoryview_thread_locks_used = 0; + + /* "View.MemoryView":318 + * DEF THREAD_LOCKS_PREALLOCATED = 8 + * cdef int __pyx_memoryview_thread_locks_used = 0 + * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ # <<<<<<<<<<<<<< + * PyThread_allocate_lock(), + * PyThread_allocate_lock(), + */ + __pyx_t_2[0] = PyThread_allocate_lock(); + __pyx_t_2[1] = PyThread_allocate_lock(); + __pyx_t_2[2] = PyThread_allocate_lock(); + __pyx_t_2[3] = PyThread_allocate_lock(); + __pyx_t_2[4] = PyThread_allocate_lock(); + __pyx_t_2[5] = PyThread_allocate_lock(); + __pyx_t_2[6] = PyThread_allocate_lock(); + __pyx_t_2[7] = PyThread_allocate_lock(); + memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_2, sizeof(__pyx_memoryview_thread_locks[0]) * (8)); + + /* "View.MemoryView":551 + * info.obj = self + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 551, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_memoryview_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 551, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_memoryview_type); + + /* "View.MemoryView":997 + * return self.from_object + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 997, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_memoryviewslice_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 997, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_memoryviewslice_type); + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum, NULL, __pyx_n_s_View_MemoryView); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Enum, __pyx_t_1) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init zoo.board_games.gomoku.envs.legal_actions_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_CLEAR(__pyx_m); + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init zoo.board_games.gomoku.envs.legal_actions_cython"); + } + __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; +} + +/* 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; +} + +/* MemviewSliceInit */ +static int +__Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview, + int ndim, + __Pyx_memviewslice *memviewslice, + int memview_is_new_reference) +{ + __Pyx_RefNannyDeclarations + int i, retval=-1; + Py_buffer *buf = &memview->view; + __Pyx_RefNannySetupContext("init_memviewslice", 0); + if (unlikely(memviewslice->memview || memviewslice->data)) { + PyErr_SetString(PyExc_ValueError, + "memviewslice is already initialized!"); + goto fail; + } + if (buf->strides) { + for (i = 0; i < ndim; i++) { + memviewslice->strides[i] = buf->strides[i]; + } + } else { + Py_ssize_t stride = buf->itemsize; + for (i = ndim - 1; i >= 0; i--) { + memviewslice->strides[i] = stride; + stride *= buf->shape[i]; + } + } + for (i = 0; i < ndim; i++) { + memviewslice->shape[i] = buf->shape[i]; + if (buf->suboffsets) { + memviewslice->suboffsets[i] = buf->suboffsets[i]; + } else { + memviewslice->suboffsets[i] = -1; + } + } + memviewslice->memview = memview; + memviewslice->data = (char *)buf->buf; + if (__pyx_add_acquisition_count(memview) == 0 && !memview_is_new_reference) { + Py_INCREF(memview); + } + retval = 0; + goto no_fail; +fail: + memviewslice->memview = 0; + memviewslice->data = 0; + retval = -1; +no_fail: + __Pyx_RefNannyFinishContext(); + return retval; +} +#ifndef Py_NO_RETURN +#define Py_NO_RETURN +#endif +static void __pyx_fatalerror(const char *fmt, ...) Py_NO_RETURN { + va_list vargs; + char msg[200]; +#if PY_VERSION_HEX >= 0x030A0000 || defined(HAVE_STDARG_PROTOTYPES) + va_start(vargs, fmt); +#else + va_start(vargs); +#endif + vsnprintf(msg, 200, fmt, vargs); + va_end(vargs); + Py_FatalError(msg); +} +static CYTHON_INLINE int +__pyx_add_acquisition_count_locked(__pyx_atomic_int *acquisition_count, + PyThread_type_lock lock) +{ + int result; + PyThread_acquire_lock(lock, 1); + result = (*acquisition_count)++; + PyThread_release_lock(lock); + return result; +} +static CYTHON_INLINE int +__pyx_sub_acquisition_count_locked(__pyx_atomic_int *acquisition_count, + PyThread_type_lock lock) +{ + int result; + PyThread_acquire_lock(lock, 1); + result = (*acquisition_count)--; + PyThread_release_lock(lock); + return result; +} +static CYTHON_INLINE void +__Pyx_INC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno) +{ + int first_time; + struct __pyx_memoryview_obj *memview = memslice->memview; + if (unlikely(!memview || (PyObject *) memview == Py_None)) + return; + if (unlikely(__pyx_get_slice_count(memview) < 0)) + __pyx_fatalerror("Acquisition count is %d (line %d)", + __pyx_get_slice_count(memview), lineno); + first_time = __pyx_add_acquisition_count(memview) == 0; + if (unlikely(first_time)) { + if (have_gil) { + Py_INCREF((PyObject *) memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_INCREF((PyObject *) memview); + PyGILState_Release(_gilstate); + } + } +} +static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *memslice, + int have_gil, int lineno) { + int last_time; + struct __pyx_memoryview_obj *memview = memslice->memview; + if (unlikely(!memview || (PyObject *) memview == Py_None)) { + memslice->memview = NULL; + return; + } + if (unlikely(__pyx_get_slice_count(memview) <= 0)) + __pyx_fatalerror("Acquisition count is %d (line %d)", + __pyx_get_slice_count(memview), lineno); + last_time = __pyx_sub_acquisition_count(memview) == 1; + memslice->data = NULL; + if (unlikely(last_time)) { + if (have_gil) { + Py_CLEAR(memslice->memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_CLEAR(memslice->memview); + PyGILState_Release(_gilstate); + } + } else { + memslice->memview = NULL; + } +} + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (exact) { + #if PY_MAJOR_VERSION == 2 + if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); + return 0; +} + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = Py_TYPE(func)->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* RaiseException */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_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 + +/* PyCFunctionFastCall */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + int flags = PyCFunction_GET_FLAGS(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { + return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); + } else { + return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + } +} +#endif + +/* PyFunctionFastCall */ +#if CYTHON_FAST_PYCALL +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif +#endif + +/* PyObjectCall2Args */ +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { + PyObject *args, *result = NULL; + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyFunction_FastCall(function, args, 2); + } + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyCFunction_FastCall(function, args, 2); + } + #endif + args = PyTuple_New(2); + if (unlikely(!args)) goto done; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + Py_INCREF(function); + result = __Pyx_PyObject_Call(function, args, NULL); + Py_DECREF(args); + Py_DECREF(function); +done: + return result; +} + +/* PyObjectCallMethO */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallOneArg */ +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif + if (likely(PyCFunction_Check(func))) { + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (__Pyx_PyFastCFunction_Check(func)) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else +#if PY_MAJOR_VERSION < 3 + PyObject* owned_ref = NULL; +#endif + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); +#if PY_MAJOR_VERSION < 3 + if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { + owned_ref = PyUnicode_FromObject(s2); + if (unlikely(!owned_ref)) + return -1; + s2 = owned_ref; + s2_is_unicode = 1; + } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { + owned_ref = PyUnicode_FromObject(s1); + if (unlikely(!owned_ref)) + return -1; + s1 = owned_ref; + s1_is_unicode = 1; + } else if (((!s2_is_unicode) & (!s1_is_unicode))) { + return __Pyx_PyBytes_Equals(s1, s2, equals); + } +#endif + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length; + int kind; + void *data1, *data2; + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + length = __Pyx_PyUnicode_GET_LENGTH(s1); + if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + #if CYTHON_PEP393_ENABLED + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + #else + hash1 = ((PyUnicodeObject*)s1)->hash; + hash2 = ((PyUnicodeObject*)s2)->hash; + #endif + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ); +return_ne: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_NE); +#endif +} + +/* DivInt[Py_ssize_t] */ +static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t a, Py_ssize_t b) { + Py_ssize_t q = a / b; + Py_ssize_t r = a - q*b; + q -= ((r != 0) & ((r ^ b) < 0)); + return q; +} + +/* GetAttr */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { +#if CYTHON_USE_TYPE_SLOTS +#if PY_MAJOR_VERSION >= 3 + if (likely(PyUnicode_Check(n))) +#else + if (likely(PyString_Check(n))) +#endif + return __Pyx_PyObject_GetAttrStr(o, n); +#endif + return PyObject_GetAttr(o, n); +} + +/* GetItemInt */ +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +/* ObjectGetItem */ +#if CYTHON_USE_TYPE_SLOTS +static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { + PyObject *runerr = NULL; + 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 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)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +/* HasAttr */ +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { + PyObject *r; + if (unlikely(!__Pyx_PyBaseString_Check(n))) { + PyErr_SetString(PyExc_TypeError, + "hasattr(): attribute name must be string"); + return -1; + } + r = __Pyx_GetAttr(o, n); + if (unlikely(!r)) { + PyErr_Clear(); + return 0; + } else { + Py_DECREF(r); + return 1; + } +} + +/* PyObject_GenericGetAttrNoDict */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'%.50s' object has no attribute '%U'", + tp->tp_name, attr_name); +#else + "'%.50s' object has no attribute '%.400s'", + tp->tp_name, PyString_AS_STRING(attr_name)); +#endif + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { + PyObject *descr; + PyTypeObject *tp = Py_TYPE(obj); + if (unlikely(!PyString_Check(attr_name))) { + return PyObject_GenericGetAttr(obj, attr_name); + } + assert(!tp->tp_dictoffset); + descr = _PyType_Lookup(tp, attr_name); + if (unlikely(!descr)) { + return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); + } + Py_INCREF(descr); + #if PY_MAJOR_VERSION < 3 + if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) + #endif + { + descrgetfunc f = Py_TYPE(descr)->tp_descr_get; + if (unlikely(f)) { + PyObject *res = f(descr, obj, (PyObject *)tp); + Py_DECREF(descr); + return res; + } + } + return descr; +} +#endif + +/* PyObject_GenericGetAttr */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { + if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { + return PyObject_GenericGetAttr(obj, attr_name); + } + return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); +} +#endif + +/* SetVTable */ +static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); +#else + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#endif + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +/* PyObjectGetAttrStrNoError */ +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +} + +/* SetupReduce */ +static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2); + if (likely(name_attr)) { + ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); + } else { + ret = -1; + } + if (unlikely(ret < 0)) { + PyErr_Clear(); + ret = 0; + } + Py_XDECREF(name_attr); + return ret; +} +static int __Pyx_setup_reduce(PyObject* type_obj) { + int ret = 0; + PyObject *object_reduce = NULL; + PyObject *object_getstate = NULL; + PyObject *object_reduce_ex = NULL; + PyObject *reduce = NULL; + PyObject *reduce_ex = NULL; + PyObject *reduce_cython = NULL; + PyObject *setstate = NULL; + PyObject *setstate_cython = NULL; + PyObject *getstate = NULL; +#if CYTHON_USE_PYTYPE_LOOKUP + getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); +#else + getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); + if (!getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (getstate) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); +#else + object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); + if (!object_getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (object_getstate != getstate) { + goto __PYX_GOOD; + } + } +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#else + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#endif + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; + if (reduce_ex == object_reduce_ex) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#else + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#endif + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; + if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { + reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); + if (likely(reduce_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (reduce == object_reduce || PyErr_Occurred()) { + goto __PYX_BAD; + } + setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); + if (!setstate) PyErr_Clear(); + if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { + setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); + if (likely(setstate_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (!setstate || PyErr_Occurred()) { + goto __PYX_BAD; + } + } + PyType_Modified((PyTypeObject*)type_obj); + } + } + goto __PYX_GOOD; +__PYX_BAD: + if (!PyErr_Occurred()) + PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); + ret = -1; +__PYX_GOOD: +#if !CYTHON_USE_PYTYPE_LOOKUP + Py_XDECREF(object_reduce); + Py_XDECREF(object_reduce_ex); + Py_XDECREF(object_getstate); + Py_XDECREF(getstate); +#endif + Py_XDECREF(reduce); + Py_XDECREF(reduce_ex); + Py_XDECREF(reduce_cython); + Py_XDECREF(setstate); + Py_XDECREF(setstate_cython); + return ret; +} + +/* CLineInTraceback */ +#ifndef CYTHON_CLINE_IN_TRACEBACK +static int __Pyx_CLineForTraceback(CYTHON_UNUSED PyThreadState *tstate, int c_line) { + PyObject *use_cline; + PyObject *ptype, *pvalue, *ptraceback; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict; +#endif + if (unlikely(!__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, *cython_runtime_dict, + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) + } else +#endif + { + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } + } + if (!use_cline) { + c_line = 0; + (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + } + else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache */ +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = NULL; + PyObject *py_funcname = NULL; + #if PY_MAJOR_VERSION < 3 + PyObject *py_srcfile = NULL; + py_srcfile = PyString_FromString(filename); + if (!py_srcfile) goto bad; + #endif + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + funcname = PyUnicode_AsUTF8(py_funcname); + if (!funcname) goto bad; + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + if (!py_funcname) goto bad; + #endif + } + #if PY_MAJOR_VERSION < 3 + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + #else + py_code = PyCode_NewEmpty(filename, funcname, py_line); + #endif + Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline + return py_code; +bad: + Py_XDECREF(py_funcname); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_srcfile); + #endif + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject *ptype, *pvalue, *ptraceback; + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); + } + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) { + /* If the code object creation fails, then we should clear the + fetched exception references and propagate the new exception */ + Py_XDECREF(ptype); + Py_XDECREF(pvalue); + Py_XDECREF(ptraceback); + goto bad; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#if PY_MAJOR_VERSION < 3 +static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { + if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); + if (__Pyx_TypeCheck(obj, __pyx_array_type)) return __pyx_array_getbuffer(obj, view, flags); + if (__Pyx_TypeCheck(obj, __pyx_memoryview_type)) return __pyx_memoryview_getbuffer(obj, view, flags); + PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); + return -1; +} +static void __Pyx_ReleaseBuffer(Py_buffer *view) { + PyObject *obj = view->obj; + if (!obj) return; + if (PyObject_CheckBuffer(obj)) { + PyBuffer_Release(view); + return; + } + if ((0)) {} + view->obj = NULL; + Py_DECREF(obj); +} +#endif + + +/* MemviewSliceIsContig */ +static int +__pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim) +{ + int i, index, step, start; + Py_ssize_t itemsize = mvs.memview->view.itemsize; + if (order == 'F') { + step = 1; + start = 0; + } else { + step = -1; + start = ndim - 1; + } + for (i = 0; i < ndim; i++) { + index = start + step * i; + if (mvs.suboffsets[index] >= 0 || mvs.strides[index] != itemsize) + return 0; + itemsize *= mvs.shape[index]; + } + return 1; +} + +/* OverlappingSlices */ +static void +__pyx_get_array_memory_extents(__Pyx_memviewslice *slice, + void **out_start, void **out_end, + int ndim, size_t itemsize) +{ + char *start, *end; + int i; + start = end = slice->data; + for (i = 0; i < ndim; i++) { + Py_ssize_t stride = slice->strides[i]; + Py_ssize_t extent = slice->shape[i]; + if (extent == 0) { + *out_start = *out_end = start; + return; + } else { + if (stride > 0) + end += stride * (extent - 1); + else + start += stride * (extent - 1); + } + } + *out_start = start; + *out_end = end + itemsize; +} +static int +__pyx_slices_overlap(__Pyx_memviewslice *slice1, + __Pyx_memviewslice *slice2, + int ndim, size_t itemsize) +{ + void *start1, *end1, *start2, *end2; + __pyx_get_array_memory_extents(slice1, &start1, &end1, ndim, itemsize); + __pyx_get_array_memory_extents(slice2, &start2, &end2, ndim, itemsize); + return (start1 < end2) && (start2 < end1); +} + +/* Capsule */ +static CYTHON_INLINE PyObject * +__pyx_capsule_create(void *p, CYTHON_UNUSED const char *sig) +{ + PyObject *cobj; +#if PY_VERSION_HEX >= 0x02070000 + cobj = PyCapsule_New(p, sig, NULL); +#else + cobj = PyCObject_FromVoidPtr(p, NULL); +#endif + return cobj; +} + +/* 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;\ + } + +/* 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_dsds_nn_int32_t(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_STRIDED), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_STRIDED) }; + int retcode; + if (obj == Py_None) { + result.memview = (struct __pyx_memoryview_obj *) Py_None; + return result; + } + retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, 0, + PyBUF_RECORDS_RO | writable_flag, 2, + &__Pyx_TypeInfo_nn_int32_t, stack, + &result, obj); + if (unlikely(retcode == -1)) + goto __pyx_fail; + return result; +__pyx_fail: + result.memview = NULL; + result.data = NULL; + return result; +} + +/* 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) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const char neg_one = (char) -1, const_zero = (char) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(char) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(char, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (char) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (char) 0; + case 1: __PYX_VERIFY_RETURN_INT(char, digit, digits[0]) + case 2: + if (8 * sizeof(char) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 2 * PyLong_SHIFT) { + return (char) (((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(char) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 3 * PyLong_SHIFT) { + return (char) (((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(char) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 4 * PyLong_SHIFT) { + return (char) (((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (char) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(char) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(char, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(char) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (char) 0; + case -1: __PYX_VERIFY_RETURN_INT(char, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(char, digit, +digits[0]) + case -2: + if (8 * sizeof(char) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(char) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + return (char) ((((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(char) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + return (char) ((((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(char) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) { + return (char) ((((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + } +#endif + if (sizeof(char) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(char, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(char) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(char, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + char val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (char) -1; + } + } else { + char val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (char) -1; + val = __Pyx_PyInt_As_char(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to char"); + return (char) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to char"); + return (char) -1; +} + +/* CheckBinaryVersion */ + static int __Pyx_check_binary_version(void) { + char ctversion[5]; + int same=1, i, found_dot; + const char* rt_from_call = Py_GetVersion(); + PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + found_dot = 0; + for (i = 0; i < 4; i++) { + if (!ctversion[i]) { + same = (rt_from_call[i] < '0' || rt_from_call[i] > '9'); + break; + } + if (rt_from_call[i] != ctversion[i]) { + same = 0; + break; + } + } + if (!same) { + char rtversion[5] = {'\0'}; + char message[200]; + for (i=0; i<4; ++i) { + if (rt_from_call[i] == '.') { + if (found_dot) break; + found_dot = 1; + } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { + break; + } + rtversion[i] = rt_from_call[i]; + } + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +/* InitStrings */ + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + if (PyObject_Hash(*t->p) == -1) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#if !CYTHON_PEP393_ENABLED +static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +} +#else +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (likely(PyUnicode_IS_ASCII(o))) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +} +#endif +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { + int retval; + if (unlikely(!x)) return -1; + retval = __Pyx_PyObject_IsTrue(x); + Py_DECREF(x); + return retval; +} +static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { +#if PY_MAJOR_VERSION >= 3 + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type %.200s). " + "The ability to return an instance of a strict subclass of int " + "is deprecated, and may be removed in a future version of Python.", + Py_TYPE(result)->tp_name)) { + Py_DECREF(result); + return NULL; + } + return result; + } +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + type_name, type_name, Py_TYPE(result)->tp_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x) || PyLong_Check(x))) +#else + if (likely(PyLong_Check(x))) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = m->nb_int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = m->nb_long(x); + } + #else + if (likely(m && m->nb_int)) { + name = "int"; + res = m->nb_int(x); + } + #endif +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Int(x); + } +#endif + if (likely(res)) { +#if PY_MAJOR_VERSION < 3 + if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { +#else + if (unlikely(!PyLong_CheckExact(res))) { +#endif + return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(b); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { + if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { + return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); +#if PY_MAJOR_VERSION < 3 + } else if (likely(PyInt_CheckExact(o))) { + return PyInt_AS_LONG(o); +#endif + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyInt_AsLong(x); + Py_DECREF(x); + return ival; + } +} +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/zoo/board_games/gomoku/envs/rule_bot_v0.py b/zoo/board_games/gomoku/envs/rule_bot_v0.py new file mode 100644 index 000000000..7a2f33e2f --- /dev/null +++ b/zoo/board_games/gomoku/envs/rule_bot_v0.py @@ -0,0 +1,315 @@ +import copy +import logging +from random import random + +import numpy as np +from ding.policy.base_policy import Policy +from collections import namedtuple +from typing import Optional, List, Dict, Any, Tuple, Union +import torch +import copy +import numpy as np +from ding.torch_utils import to_device +from ding.rl_utils import get_train_sample +from ding.utils import POLICY_REGISTRY +from ding.utils.data import default_collate, default_decollate +from zoo.board_games.gomoku.envs.utils import check_action_to_special_connect4_case1, \ + check_action_to_special_connect4_case2, \ + check_action_to_connect4 + + + + + +@POLICY_REGISTRY.register('gomoku_bot_v0') +class GomokuBotV0(Policy): + """ + Overview: + Hard coded expert agent for tictactoe env. + """ + config = dict( + # (str) RL policy register name (refer to function "POLICY_REGISTRY"). + type='gomoku_bot_v0', + cuda=False, + on_policy=True, + learn=dict( + multi_gpu=False, + ), + collect=dict( + unroll_len=1, + ), + eval=dict(), + ) + + def legal_actions(self, board): + legal_actions = [] + for i in range(self.board_size): + for j in range(self.board_size): + if board[i][j] == 0: + legal_actions.append(i * self.board_size + j) + return legal_actions + def rule_bot_v0(self, obs): + """ + Overview: + Hard coded agent v0 for gomoku env. + Considering the situation of to-connect-4 and to-connect-5 in a sliding window of 5X5, and lacks the consideration of the entire chessboard. + In each sliding window of 5X5, first random sample a action from legal_actions, + then take the action that will lead a connect4 or connect-5 of current/oppenent player's pieces. + Returns: + - action (:obj:`int`): the expert action to take in the current game state. + """ + board = obs['board'] + assert self.board_size >= 5, "current rule_bot_v0 is only support self.board_size>=5!" + # To easily calculate expert action, we convert the chessboard notation: + # from player 1: 1, player 2: 2 + # to player 1: -1, player 2: 1 + # TODO: more elegant implementation + board_deepcopy = copy.deepcopy(board) + for i in range(board_deepcopy.shape[0]): + for j in range(board_deepcopy.shape[1]): + if board_deepcopy[i][j] == 1: + board_deepcopy[i][j] = -1 + elif board_deepcopy[i][j] == 2: + board_deepcopy[i][j] = 1 + + # first random sample a action from legal_actions + action = np.random.choice(self.legal_actions(board_deepcopy)) + + size_of_board_template = 5 + shift_distance = [ + [i, j] for i in range(self.board_size - size_of_board_template + 1) + for j in range(self.board_size - size_of_board_template + 1) + ] + action_block_opponent_to_connect5 = None + action_to_connect4 = None + action_to_special_connect4_case1 = None + action_to_special_connect4_case2 = None + + min_to_connect = 3 + + for board_block_index in range((self.board_size - size_of_board_template + 1) ** 2): + """ + e.g., self.board_size=6 + board_block_index =[0,1,2,3] + shift_distance = (0,0), (0,1), (1,0), (1,1) + """ + shfit_tmp_board = copy.deepcopy( + board_deepcopy[shift_distance[board_block_index][0]:size_of_board_template + + shift_distance[board_block_index][0], + shift_distance[board_block_index][1]:size_of_board_template + + shift_distance[board_block_index][1]] + ) + + # Horizontal and vertical checks + for i in range(size_of_board_template): + if abs(sum(shfit_tmp_board[i, :])) >= min_to_connect: + # if i-th horizontal line has three same pieces and two empty position, or four same pieces and one opponent piece. + # e.g., case1: .xxx. , case2: oxxxx + + # find the index in the i-th horizontal line + zero_position_index = np.where(shfit_tmp_board[i, :] == 0)[0] + if zero_position_index.shape[0] == 0: + logging.debug( + 'there is no empty position in this searched five positions, continue to search...' + ) + else: + if zero_position_index.shape[0] == 2: + ind = random.choice(zero_position_index) + elif zero_position_index.shape[0] == 1: + ind = zero_position_index[0] + # convert ind to action + # the action that will lead a connect5 of current or opponent player's pieces + action = np.ravel_multi_index( + ( + np.array([i + shift_distance[board_block_index][0]] + ), np.array([ind + shift_distance[board_block_index][1]]) + ), (self.board_size, self.board_size) + )[0] + if self.check_action_to_connect4_in_bot_v0: + if check_action_to_special_connect4_case1(shfit_tmp_board[i, :]): + action_to_special_connect4_case1 = action + if check_action_to_special_connect4_case2(shfit_tmp_board[i, :]): + action_to_special_connect4_case2 = action + if check_action_to_connect4(shfit_tmp_board[i, :]): + action_to_connect4 = action + if (self.current_player_to_compute_bot_action * sum(shfit_tmp_board[i, :]) > 0) and abs(sum( + shfit_tmp_board[i, :])) == size_of_board_template - 1: + # immediately take the action that will lead a connect5 of current player's pieces + return action + if (self.current_player_to_compute_bot_action * sum(shfit_tmp_board[i, :]) < 0) and abs(sum( + shfit_tmp_board[i, :])) == size_of_board_template - 1: + # memory the action that will lead a connect5 of opponent player's pieces, to avoid the forget + action_block_opponent_to_connect5 = action + + if abs(sum(shfit_tmp_board[:, i])) >= min_to_connect: + # if i-th vertical has three same pieces and two empty position, or four same pieces and one opponent piece. + # e.g., case1: .xxx. , case2: oxxxx + + # find the index in the i-th vertical line + zero_position_index = np.where(shfit_tmp_board[:, i] == 0)[0] + if zero_position_index.shape[0] == 0: + logging.debug( + 'there is no empty position in this searched five positions, continue to search...' + ) + else: + if zero_position_index.shape[0] == 2: + ind = random.choice(zero_position_index) + elif zero_position_index.shape[0] == 1: + ind = zero_position_index[0] + + # convert ind to action + # the action that will lead a connect5 of current or opponent player's pieces + action = np.ravel_multi_index( + ( + np.array([ind + shift_distance[board_block_index][0]] + ), np.array([i + shift_distance[board_block_index][1]]) + ), (self.board_size, self.board_size) + )[0] + if self.check_action_to_connect4_in_bot_v0: + if check_action_to_special_connect4_case1(shfit_tmp_board[:, i]): + action_to_special_connect4_case1 = action + if check_action_to_special_connect4_case2(shfit_tmp_board[:, i]): + action_to_special_connect4_case2 = action + if check_action_to_connect4(shfit_tmp_board[:, i]): + action_to_connect4 = action + if (self.current_player_to_compute_bot_action * sum(shfit_tmp_board[:, i]) > 0) and abs(sum( + shfit_tmp_board[:, i])) == size_of_board_template - 1: + # immediately take the action that will lead a connect5 of current player's pieces + return action + if (self.current_player_to_compute_bot_action * sum(shfit_tmp_board[:, i]) < 0) and abs(sum( + shfit_tmp_board[:, i])) == size_of_board_template - 1: + # memory the action that will lead a connect5 of opponent player's pieces, to avoid the forget + action_block_opponent_to_connect5 = action + + # Diagonal checks + diag = shfit_tmp_board.diagonal() + anti_diag = np.fliplr(shfit_tmp_board).diagonal() + if abs(sum(diag)) >= min_to_connect: + # if diagonal has three same pieces and two empty position, or four same pieces and one opponent piece. + # e.g., case1: .xxx. , case2: oxxxx + # find the index in the diag vector + + zero_position_index = np.where(diag == 0)[0] + if zero_position_index.shape[0] == 0: + logging.debug( + 'there is no empty position in this searched five positions, continue to search...') + else: + if zero_position_index.shape[0] == 2: + ind = random.choice(zero_position_index) + elif zero_position_index.shape[0] == 1: + ind = zero_position_index[0] + + # convert ind to action + # the action that will lead a connect5 of current or opponent player's pieces + action = np.ravel_multi_index( + ( + np.array([ind + shift_distance[board_block_index][0]] + ), np.array([ind + shift_distance[board_block_index][1]]) + ), (self.board_size, self.board_size) + )[0] + if self.check_action_to_connect4_in_bot_v0: + if check_action_to_special_connect4_case1(diag): + action_to_special_connect4_case1 = action + if check_action_to_special_connect4_case2(diag): + action_to_special_connect4_case2 = action + if check_action_to_connect4(diag): + action_to_connect4 = action + if self.current_player_to_compute_bot_action * sum(diag) > 0 and abs( + sum(diag)) == size_of_board_template - 1: + # immediately take the action that will lead a connect5 of current player's pieces + return action + if self.current_player_to_compute_bot_action * sum(diag) < 0 and abs( + sum(diag)) == size_of_board_template - 1: + # memory the action that will lead a connect5 of opponent player's pieces, to avoid the forget + action_block_opponent_to_connect5 = action + + if abs(sum(anti_diag)) >= min_to_connect: + # if anti-diagonal has three same pieces and two empty position, or four same pieces and one opponent piece. + # e.g., case1: .xxx. , case2: oxxxx + + # find the index in the anti_diag vector + zero_position_index = np.where(anti_diag == 0)[0] + if zero_position_index.shape[0] == 0: + logging.debug( + 'there is no empty position in this searched five positions, continue to search...') + else: + if zero_position_index.shape[0] == 2: + ind = random.choice(zero_position_index) + elif zero_position_index.shape[0] == 1: + ind = zero_position_index[0] + # convert ind to action + # the action that will lead a connect5 of current or opponent player's pieces + action = np.ravel_multi_index( + ( + np.array([ind + shift_distance[board_block_index][0]]), + np.array([size_of_board_template - 1 - ind + shift_distance[board_block_index][1]]) + ), (self.board_size, self.board_size) + )[0] + if self.check_action_to_connect4_in_bot_v0: + if check_action_to_special_connect4_case1(anti_diag): + action_to_special_connect4_case1 = action + if check_action_to_special_connect4_case2(anti_diag): + action_to_special_connect4_case2 = action + if check_action_to_connect4(anti_diag): + action_to_connect4 = action + if self.current_player_to_compute_bot_action * sum(anti_diag) > 0 and abs( + sum(anti_diag)) == size_of_board_template - 1: + # immediately take the action that will lead a connect5 of current player's pieces + return action + if self.current_player_to_compute_bot_action * sum(anti_diag) < 0 and abs( + sum(anti_diag)) == size_of_board_template - 1: + # memory the action that will lead a connect5 of opponent player's pieces, to avoid the forget + action_block_opponent_to_connect5 = action + + if action_block_opponent_to_connect5 is not None: + return action_block_opponent_to_connect5 + elif action_to_special_connect4_case1 is not None: + return action_to_special_connect4_case1 + elif action_to_special_connect4_case2 is not None: + return action_to_special_connect4_case2 + elif action_to_connect4 is not None: + return action_to_connect4 + else: + return action + + def _init_learn(self) -> None: + pass + + def _init_collect(self) -> None: + self.board_size = self._cfg.board_size + pass + + def _init_eval(self) -> None: + pass + + def _forward_learn(self, data: dict) -> dict: + pass + + def _forward_collect(self, envs: Dict, obs: Dict, temperature: float = 1) -> Dict[str, torch.Tensor]: + ready_env_id = list(envs.keys()) + output = {} + for env_id in ready_env_id: + action = self.rule_bot_v0(obs[env_id]) + output[env_id] = { + 'action': action, + 'probs': None, + } + return output + + def _forward_eval(self, data: dict) -> dict: + pass + + def _process_transition(self, obs: Any, model_output: dict, timestep: namedtuple) -> dict: + pass + + def _get_train_sample(self, data: list) -> Union[None, List[Any]]: + pass + + def default_model(self) -> Tuple[str, List[str]]: + return 'bot_model', ['lzero.model.bot_model'] + + def _monitor_vars_learn(self) -> List[str]: + pass + + def reset(self): + pass diff --git a/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py b/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py index 7fff78ce4..0ca76dfd3 100644 --- a/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py +++ b/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py @@ -10,7 +10,8 @@ update_per_collect = 50 batch_size = 256 max_env_step = int(2e5) -sp_prob = 1 +sp_prob = 0. # TODO(pu): 0, 0.8, 1 + # collector_env_num = 2 # n_episode = 2 @@ -49,8 +50,6 @@ # We use the small size model for tictactoe. num_res_blocks=1, num_channels=16, - fc_value_layers=[8], - fc_policy_layers=[8], ), cuda=True, board_size=3, @@ -88,6 +87,8 @@ ), use_pretrain=False, use_pretrain_init_historical=False, + # "use_bot_init_historica" means whether to use bot as an init historical player + use_bot_init_historical=True, payoff=dict( type='battle', decay=0.99, diff --git a/zoo/board_games/tictactoe/envs/get_done_winner_cython.cpp b/zoo/board_games/tictactoe/envs/get_done_winner_cython.cpp new file mode 100644 index 000000000..2f447fe33 --- /dev/null +++ b/zoo/board_games/tictactoe/envs/get_done_winner_cython.cpp @@ -0,0 +1,21717 @@ +/* Generated by Cython 0.29.34 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [], + "include_dirs": [ + "/private/var/folders/r5/znmp_3cn0_b41yvr2tvld9ys0qypks/T/pip-build-env-6l8r0sjs/overlay/lib/python3.8/site-packages/numpy/core/include" + ], + "language": "c++", + "name": "zoo.board_games.tictactoe.envs.get_done_winner_cython", + "sources": [ + "/Users/puyuan/code/LightZero/zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx" + ] + }, + "module_name": "zoo.board_games.tictactoe.envs.get_done_winner_cython" +} +END: Cython Metadata */ + +#ifndef PY_SSIZE_T_CLEAN +#define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.6+ or Python 3.3+. +#else +#define CYTHON_ABI "0_29_34" +#define CYTHON_HEX_VERSION 0x001D22F0 +#define CYTHON_FUTURE_DIVISION 1 +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#define __PYX_COMMA , +#ifndef HAVE_LONG_LONG + #if PY_VERSION_HEX >= 0x02070000 + #define HAVE_LONG_LONG + #endif +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif +#elif defined(PY_NOGIL) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_NOGIL 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #ifndef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_NOGIL 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #define CYTHON_USE_PYLONG_INTERNALS (PY_VERSION_HEX < 0x030C00A5) + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #if PY_VERSION_HEX >= 0x030B00A4 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #elif !defined(CYTHON_FAST_THREAD_STATE) + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #endif + #ifndef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS ((PY_VERSION_HEX >= 0x030600B1) && (PY_VERSION_HEX < 0x030C00A5)) + #endif + #if PY_VERSION_HEX >= 0x030B00A4 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #elif !defined(CYTHON_USE_EXC_INFO_STACK) + #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #endif + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_MAJOR_VERSION < 3 + #include "longintrepr.h" + #endif + #undef SHIFT + #undef BASE + #undef MASK + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + #endif +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) +#ifdef _MSC_VER + #ifndef _MSC_STDINT_H_ + #if _MSC_VER < 1300 + typedef unsigned char uint8_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int32 uint32_t; + #endif + #endif +#else + #include +#endif +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) && __cplusplus >= 201103L + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #elif __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + #if defined(__clang__ ) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif + +#ifndef __cplusplus + #error "Cython files generated with the C++ option must be compiled with a C++ compiler." +#endif +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #else + #define CYTHON_INLINE inline + #endif +#endif +template +void __Pyx_call_destructor(T& x) { + x.~T(); +} +template +class __Pyx_FakeReference { + public: + __Pyx_FakeReference() : ptr(NULL) { } + __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { } + T *operator->() { return ptr; } + T *operator&() { return ptr; } + operator T&() { return *ptr; } + template bool operator ==(U other) { return *ptr == other; } + template bool operator !=(U other) { return *ptr != other; } + private: + T *ptr; +}; + +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_DefaultClassType PyType_Type +#if PY_VERSION_HEX >= 0x030B00A1 + static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; + PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; + const char *fn_cstr=NULL; + const char *name_cstr=NULL; + PyCodeObject* co=NULL; + PyObject *type, *value, *traceback; + PyErr_Fetch(&type, &value, &traceback); + if (!(kwds=PyDict_New())) goto end; + if (!(argcount=PyLong_FromLong(a))) goto end; + if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; + if (!(posonlyargcount=PyLong_FromLong(0))) goto end; + if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; + if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; + if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; + if (!(nlocals=PyLong_FromLong(l))) goto end; + if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; + if (!(stacksize=PyLong_FromLong(s))) goto end; + if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; + if (!(flags=PyLong_FromLong(f))) goto end; + if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; + if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; + if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; + if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; + if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; + if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here + if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; + Py_XDECREF((PyObject*)co); + co = (PyCodeObject*)call_result; + call_result = NULL; + if (0) { + cleanup_code_too: + Py_XDECREF((PyObject*)co); + co = NULL; + } + end: + Py_XDECREF(kwds); + Py_XDECREF(argcount); + Py_XDECREF(posonlyargcount); + Py_XDECREF(kwonlyargcount); + Py_XDECREF(nlocals); + Py_XDECREF(stacksize); + Py_XDECREF(replace); + Py_XDECREF(call_result); + Py_XDECREF(empty); + if (type) { + PyErr_Restore(type, value, traceback); + } + return co; + } +#else + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#endif + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef METH_STACKLESS + #define METH_STACKLESS 0 +#endif +#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) + #ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #define __Pyx_PyCFunctionFast _PyCFunctionFast + #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords +#endif +#if CYTHON_FAST_PYCCALL +#define __Pyx_PyFastCFunction_Check(func)\ + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +#else +#define __Pyx_PyFastCFunction_Check(func) 0 +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 + #define PyMem_RawMalloc(n) PyMem_Malloc(n) + #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) + #define PyMem_RawFree(p) PyMem_Free(p) +#endif +#if CYTHON_COMPILING_IN_PYSTON + #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x03060000 + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#elif PY_VERSION_HEX >= 0x03000000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_Current +#endif +#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) +#include "pythread.h" +#define Py_tss_NEEDS_INIT 0 +typedef int Py_tss_t; +static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { + *key = PyThread_create_key(); + return 0; +} +static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { + Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); + *key = Py_tss_NEEDS_INIT; + return key; +} +static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { + PyObject_Free(key); +} +static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { + return *key != Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { + PyThread_delete_key(*key); + *key = Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { + return PyThread_set_key_value(*key, value); +} +static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { + return PyThread_get_key_value(*key); +} +#endif +#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif +#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#else +#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #if 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_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 PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #else + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif + #endif +#else + #define CYTHON_PEP393_ENABLED 0 + #define PyUnicode_1BYTE_KIND 1 + #define PyUnicode_2BYTE_KIND 2 + #define PyUnicode_4BYTE_KIND 4 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#ifndef PyObject_Unicode + #define PyObject_Unicode PyObject_Str +#endif +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) +#else + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef __Pyx_PyAsyncMethodsStruct + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; +#endif + +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #if !defined(_USE_MATH_DEFINES) + #define _USE_MATH_DEFINES + #endif +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + +#define __PYX_MARK_ERR_POS(f_index, lineno) \ + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__zoo__board_games__tictactoe__envs__get_done_winner_cython +#define __PYX_HAVE_API__zoo__board_games__tictactoe__envs__get_done_winner_cython +/* Early includes */ +#include +#include "pythread.h" +#include +#include +#include +#include "pystate.h" +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { + return (size_t) i < (size_t) limit; +} +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) + #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +#define __Pyx_PySequence_Tuple(obj)\ + (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); +#if CYTHON_ASSUME_SAFE_MACROS +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } + +static PyObject *__pyx_m = NULL; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_cython_runtime = NULL; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + + +static const char *__pyx_f[] = { + "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx", + "stringsource", +}; +/* MemviewSliceStruct.proto */ +struct __pyx_memoryview_obj; +typedef struct { + struct __pyx_memoryview_obj *memview; + char *data; + Py_ssize_t shape[8]; + Py_ssize_t strides[8]; + Py_ssize_t suboffsets[8]; +} __Pyx_memviewslice; +#define __Pyx_MemoryView_Len(m) (m.shape[0]) + +/* Atomics.proto */ +#include +#ifndef CYTHON_ATOMICS + #define CYTHON_ATOMICS 1 +#endif +#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS +#define __pyx_atomic_int_type int +#if CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\ + (__GNUC_MINOR__ > 1 ||\ + (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) + #define __pyx_atomic_incr_aligned(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_decr_aligned(value) __sync_fetch_and_sub(value, 1) + #ifdef __PYX_DEBUG_ATOMICS + #warning "Using GNU atomics" + #endif +#elif CYTHON_ATOMICS && defined(_MSC_VER) && CYTHON_COMPILING_IN_NOGIL + #include + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type long + #pragma intrinsic (_InterlockedExchangeAdd) + #define __pyx_atomic_incr_aligned(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_decr_aligned(value) _InterlockedExchangeAdd(value, -1) + #ifdef __PYX_DEBUG_ATOMICS + #pragma message ("Using MSVC atomics") + #endif +#else + #undef CYTHON_ATOMICS + #define CYTHON_ATOMICS 0 + #ifdef __PYX_DEBUG_ATOMICS + #warning "Not using atomics" + #endif +#endif +typedef volatile __pyx_atomic_int_type __pyx_atomic_int; +#if CYTHON_ATOMICS + #define __pyx_add_acquisition_count(memview)\ + __pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview)) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview)) +#else + #define __pyx_add_acquisition_count(memview)\ + __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) +#endif + +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + +/* NoFastGil.proto */ +#define __Pyx_PyGILState_Ensure PyGILState_Ensure +#define __Pyx_PyGILState_Release PyGILState_Release +#define __Pyx_FastGIL_Remember() +#define __Pyx_FastGIL_Forget() +#define __Pyx_FastGilFuncInit() + +/* BufferFormatStructs.proto */ +#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; + +/* "View.MemoryView":106 + * + * @cname("__pyx_array") + * cdef class array: # <<<<<<<<<<<<<< + * + * cdef: + */ +struct __pyx_array_obj { + PyObject_HEAD + struct __pyx_vtabstruct_array *__pyx_vtab; + char *data; + Py_ssize_t len; + char *format; + int ndim; + Py_ssize_t *_shape; + Py_ssize_t *_strides; + Py_ssize_t itemsize; + PyObject *mode; + PyObject *_format; + void (*callback_free_data)(void *); + int free_data; + int dtype_is_object; +}; + + +/* "View.MemoryView":280 + * + * @cname('__pyx_MemviewEnum') + * cdef class Enum(object): # <<<<<<<<<<<<<< + * cdef object name + * def __init__(self, name): + */ +struct __pyx_MemviewEnum_obj { + PyObject_HEAD + PyObject *name; +}; + + +/* "View.MemoryView":331 + * + * @cname('__pyx_memoryview') + * cdef class memoryview(object): # <<<<<<<<<<<<<< + * + * cdef object obj + */ +struct __pyx_memoryview_obj { + PyObject_HEAD + struct __pyx_vtabstruct_memoryview *__pyx_vtab; + PyObject *obj; + PyObject *_size; + PyObject *_array_interface; + PyThread_type_lock lock; + __pyx_atomic_int acquisition_count[2]; + __pyx_atomic_int *acquisition_count_aligned_p; + Py_buffer view; + int flags; + int dtype_is_object; + __Pyx_TypeInfo *typeinfo; +}; + + +/* "View.MemoryView":967 + * + * @cname('__pyx_memoryviewslice') + * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< + * "Internal class for passing memoryview slices to Python" + * + */ +struct __pyx_memoryviewslice_obj { + struct __pyx_memoryview_obj __pyx_base; + __Pyx_memviewslice from_slice; + PyObject *from_object; + PyObject *(*to_object_func)(char *); + int (*to_dtype_func)(char *, PyObject *); +}; + + + +/* "View.MemoryView":106 + * + * @cname("__pyx_array") + * cdef class array: # <<<<<<<<<<<<<< + * + * cdef: + */ + +struct __pyx_vtabstruct_array { + PyObject *(*get_memview)(struct __pyx_array_obj *); +}; +static struct __pyx_vtabstruct_array *__pyx_vtabptr_array; + + +/* "View.MemoryView":331 + * + * @cname('__pyx_memoryview') + * cdef class memoryview(object): # <<<<<<<<<<<<<< + * + * cdef object obj + */ + +struct __pyx_vtabstruct_memoryview { + char *(*get_item_pointer)(struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*is_slice)(struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*setitem_slice_assignment)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); + PyObject *(*setitem_slice_assign_scalar)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*setitem_indexed)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); + PyObject *(*convert_item_to_object)(struct __pyx_memoryview_obj *, char *); + PyObject *(*assign_item_from_object)(struct __pyx_memoryview_obj *, char *, PyObject *); +}; +static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview; + + +/* "View.MemoryView":967 + * + * @cname('__pyx_memoryviewslice') + * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< + * "Internal class for passing memoryview slices to Python" + * + */ + +struct __pyx_vtabstruct__memoryviewslice { + struct __pyx_vtabstruct_memoryview __pyx_base; +}; +static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice; + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* 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); + +/* None.proto */ +static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); + +/* 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); + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* PyCFunctionFastCall.proto */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#else +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); +#else +#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) +#endif +#define __Pyx_BUILD_ASSERT_EXPR(cond)\ + (sizeof(char [1 - 2*!(cond)]) - 1) +#ifndef Py_MEMBER_SIZE +#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) +#endif +#if CYTHON_FAST_PYCALL + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" +#if PY_VERSION_HEX >= 0x030b00a6 + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif + #define __Pxy_PyFrame_Initialize_Offsets()\ + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) + #define __Pyx_PyFrame_GetLocalsplus(frame)\ + (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#endif // CYTHON_FAST_PYCALL +#endif + +/* PyObjectCall2Args.proto */ +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* StrEquals.proto */ +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals +#else +#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals +#endif + +/* DivInt[Py_ssize_t].proto */ +static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t, Py_ssize_t); + +/* UnaryNegOverflows.proto */ +#define UNARY_NEG_WOULD_OVERFLOW(x)\ + (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x))) + +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *); /*proto*/ +/* GetAttr.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); + +/* 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) do {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ + (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ + __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ + PY_UINT64_T __pyx_dict_version;\ + PyObject *__pyx_dict_cached_value;\ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); +#else +#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) +#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); +#endif + +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/* RaiseNoneIterError.proto */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* GetTopmostException.proto */ +#if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); +#endif + +/* SaveResetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +#else +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/* GetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* SwapException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* Import.proto */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level); + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); +#else +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2)) +#endif +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) + +static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +/* ListCompAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len)) { + Py_INCREF(x); + PyList_SET_ITEM(list, len, x); + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) +#endif + +/* PyIntBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_PyInt_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyInt_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) +#endif + +/* ListExtend.proto */ +static CYTHON_INLINE int __Pyx_PyList_Extend(PyObject* L, PyObject* v) { +#if CYTHON_COMPILING_IN_CPYTHON + PyObject* none = _PyList_Extend((PyListObject*)L, v); + if (unlikely(!none)) + return -1; + Py_DECREF(none); + return 0; +#else + return PyList_SetSlice(L, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, v); +#endif +} + +/* ListAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) { + Py_INCREF(x); + PyList_SET_ITEM(list, len, x); + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#endif + +/* DivInt[long].proto */ +static CYTHON_INLINE long __Pyx_div_long(long, long); + +/* PySequenceContains.proto */ +static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { + int result = PySequence_Contains(seq, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +/* ImportFrom.proto */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +/* HasAttr.proto */ +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); + +/* PyObject_GenericGetAttrNoDict.proto */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GenericGetAttrNoDict PyObject_GenericGetAttr +#endif + +/* PyObject_GenericGetAttr.proto */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GenericGetAttr PyObject_GenericGetAttr +#endif + +/* SetVTable.proto */ +static int __Pyx_SetVtable(PyObject *dict, void *vtable); + +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + +/* SetupReduce.proto */ +static int __Pyx_setup_reduce(PyObject* type_obj); + +/* CLineInTraceback.proto */ +#ifdef CYTHON_CLINE_IN_TRACEBACK +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#else +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#endif + +/* CodeObjectCache.proto */ +typedef struct { + PyCodeObject* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; +}; +static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static PyCodeObject *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +#if PY_MAJOR_VERSION < 3 + static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags); + static void __Pyx_ReleaseBuffer(Py_buffer *view); +#else + #define __Pyx_GetBuffer PyObject_GetBuffer + #define __Pyx_ReleaseBuffer PyBuffer_Release +#endif + + +/* BufferStructDeclare.proto */ +typedef struct { + Py_ssize_t shape, strides, suboffsets; +} __Pyx_Buf_DimInfo; +typedef struct { + size_t refcount; + Py_buffer pybuffer; +} __Pyx_Buffer; +typedef struct { + __Pyx_Buffer *rcbuffer; + char *data; + __Pyx_Buf_DimInfo diminfo[8]; +} __Pyx_LocalBuf_ND; + +/* MemviewSliceIsContig.proto */ +static int __pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim); + +/* OverlappingSlices.proto */ +static int __pyx_slices_overlap(__Pyx_memviewslice *slice1, + __Pyx_memviewslice *slice2, + int ndim, size_t itemsize); + +/* Capsule.proto */ +static CYTHON_INLINE PyObject *__pyx_capsule_create(void *p, const char *sig); + +/* IsLittleEndian.proto */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); + +/* BufferFormatCheck.proto */ +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type); + +/* TypeInfoCompare.proto */ +static int __pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b); + +/* MemviewSliceValidateAndInit.proto */ +static int __Pyx_ValidateAndInit_memviewslice( + int *axes_specs, + int c_or_f_flag, + int buf_flags, + int ndim, + __Pyx_TypeInfo *dtype, + __Pyx_BufFmt_StackElem stack[], + __Pyx_memviewslice *memviewslice, + PyObject *original_obj); + +/* ObjectToMemviewSlice.proto */ +static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dsds_nn_int32_t(PyObject *, int writable_flag); + +/* GCCDiagnostics.proto */ +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + +/* MemviewSliceCopyTemplate.proto */ +static __Pyx_memviewslice +__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, + const char *mode, int ndim, + size_t sizeof_dtype, int contig_flag, + int dtype_is_object); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int32_t __Pyx_PyInt_As_int32_t(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int32_t(int32_t value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* 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 'libc.stdint' */ + +/* Module declarations from 'cython.view' */ + +/* Module declarations from 'cython' */ + +/* Module declarations from 'zoo.board_games.tictactoe.envs.get_done_winner_cython' */ +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 PyObject *__pyx_f_3zoo_11board_games_9tictactoe_4envs_22get_done_winner_cython_get_done_winner_cython(__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_nn_int32_t = { "int32_t", NULL, sizeof(int32_t), { 0 }, 0, IS_UNSIGNED(int32_t) ? 'U' : 'I', IS_UNSIGNED(int32_t), 0 }; +#define __Pyx_MODULE_NAME "zoo.board_games.tictactoe.envs.get_done_winner_cython" +extern int __pyx_module_is_main_zoo__board_games__tictactoe__envs__get_done_winner_cython; +int __pyx_module_is_main_zoo__board_games__tictactoe__envs__get_done_winner_cython = 0; + +/* Implementation of 'zoo.board_games.tictactoe.envs.get_done_winner_cython' */ +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_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_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_fortran[] = "fortran"; +static const char __pyx_k_memview[] = "memview"; +static const char __pyx_k_Ellipsis[] = "Ellipsis"; +static const char __pyx_k_getstate[] = "__getstate__"; +static const char __pyx_k_itemsize[] = "itemsize"; +static const char __pyx_k_pyx_type[] = "__pyx_type"; +static const char __pyx_k_setstate[] = "__setstate__"; +static const char __pyx_k_TypeError[] = "TypeError"; +static const char __pyx_k_enumerate[] = "enumerate"; +static const char __pyx_k_pyx_state[] = "__pyx_state"; +static const char __pyx_k_reduce_ex[] = "__reduce_ex__"; +static const char __pyx_k_IndexError[] = "IndexError"; +static const char __pyx_k_ValueError[] = "ValueError"; +static const char __pyx_k_pyx_result[] = "__pyx_result"; +static const char __pyx_k_pyx_vtable[] = "__pyx_vtable__"; +static const char __pyx_k_MemoryError[] = "MemoryError"; +static const char __pyx_k_PickleError[] = "PickleError"; +static const char __pyx_k_pyx_checksum[] = "__pyx_checksum"; +static const char __pyx_k_stringsource[] = "stringsource"; +static const char __pyx_k_pyx_getbuffer[] = "__pyx_getbuffer"; +static const char __pyx_k_reduce_cython[] = "__reduce_cython__"; +static const char __pyx_k_View_MemoryView[] = "View.MemoryView"; +static const char __pyx_k_allocate_buffer[] = "allocate_buffer"; +static const char __pyx_k_dtype_is_object[] = "dtype_is_object"; +static const char __pyx_k_pyx_PickleError[] = "__pyx_PickleError"; +static const char __pyx_k_setstate_cython[] = "__setstate_cython__"; +static const char __pyx_k_pyx_unpickle_Enum[] = "__pyx_unpickle_Enum"; +static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback"; +static const char __pyx_k_strided_and_direct[] = ""; +static const char __pyx_k_strided_and_indirect[] = ""; +static const char __pyx_k_contiguous_and_direct[] = ""; +static const char __pyx_k_MemoryView_of_r_object[] = ""; +static const char __pyx_k_MemoryView_of_r_at_0x_x[] = ""; +static const char __pyx_k_contiguous_and_indirect[] = ""; +static const char __pyx_k_Cannot_index_with_type_s[] = "Cannot index with type '%s'"; +static const char __pyx_k_Invalid_shape_in_axis_d_d[] = "Invalid shape in axis %d: %d."; +static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array"; +static const char __pyx_k_unable_to_allocate_array_data[] = "unable to allocate array data."; +static const char __pyx_k_strided_and_direct_or_indirect[] = ""; +static const char __pyx_k_Buffer_view_does_not_expose_stri[] = "Buffer view does not expose strides"; +static const char __pyx_k_Can_only_create_a_buffer_that_is[] = "Can only create a buffer that is contiguous in memory."; +static const char __pyx_k_Cannot_assign_to_read_only_memor[] = "Cannot assign to read-only memoryview"; +static const char __pyx_k_Cannot_create_writable_memory_vi[] = "Cannot create writable memory view from read-only memoryview"; +static const char __pyx_k_Empty_shape_tuple_for_cython_arr[] = "Empty shape tuple for cython.array"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))"; +static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported"; +static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got %s"; +static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis %d)"; +static const char __pyx_k_Unable_to_convert_item_to_object[] = "Unable to convert item to object"; +static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension %d (got %d and %d)"; +static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; +static const char __pyx_k_unable_to_allocate_shape_and_str[] = "unable to allocate shape and strides."; +static PyObject *__pyx_n_s_ASCII; +static PyObject *__pyx_kp_s_Buffer_view_does_not_expose_stri; +static PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is; +static PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor; +static PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi; +static PyObject *__pyx_kp_s_Cannot_index_with_type_s; +static PyObject *__pyx_n_s_Ellipsis; +static PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr; +static PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; +static PyObject *__pyx_n_s_IndexError; +static PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte; +static PyObject *__pyx_kp_s_Invalid_mode_expected_c_or_fortr; +static PyObject *__pyx_kp_s_Invalid_shape_in_axis_d_d; +static PyObject *__pyx_n_s_MemoryError; +static PyObject *__pyx_kp_s_MemoryView_of_r_at_0x_x; +static PyObject *__pyx_kp_s_MemoryView_of_r_object; +static PyObject *__pyx_n_b_O; +static PyObject *__pyx_kp_s_Out_of_bounds_on_buffer_access_a; +static PyObject *__pyx_n_s_PickleError; +static PyObject *__pyx_n_s_TypeError; +static PyObject *__pyx_kp_s_Unable_to_convert_item_to_object; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_View_MemoryView; +static PyObject *__pyx_n_s_allocate_buffer; +static PyObject *__pyx_n_s_base; +static PyObject *__pyx_n_s_c; +static PyObject *__pyx_n_u_c; +static PyObject *__pyx_n_s_class; +static PyObject *__pyx_n_s_cline_in_traceback; +static PyObject *__pyx_kp_s_contiguous_and_direct; +static PyObject *__pyx_kp_s_contiguous_and_indirect; +static PyObject *__pyx_n_s_dict; +static PyObject *__pyx_n_s_dtype_is_object; +static PyObject *__pyx_n_s_encode; +static PyObject *__pyx_n_s_enumerate; +static PyObject *__pyx_n_s_error; +static PyObject *__pyx_n_s_flags; +static PyObject *__pyx_n_s_format; +static PyObject *__pyx_n_s_fortran; +static PyObject *__pyx_n_u_fortran; +static PyObject *__pyx_n_s_getstate; +static PyObject *__pyx_kp_s_got_differing_extents_in_dimensi; +static PyObject *__pyx_n_s_id; +static PyObject *__pyx_n_s_import; +static PyObject *__pyx_n_s_itemsize; +static PyObject *__pyx_kp_s_itemsize_0_for_cython_array; +static PyObject *__pyx_n_s_main; +static PyObject *__pyx_n_s_memview; +static PyObject *__pyx_n_s_mode; +static PyObject *__pyx_n_s_name; +static PyObject *__pyx_n_s_name_2; +static PyObject *__pyx_n_s_ndim; +static PyObject *__pyx_n_s_new; +static PyObject *__pyx_kp_s_no_default___reduce___due_to_non; +static PyObject *__pyx_n_s_obj; +static PyObject *__pyx_n_s_pack; +static PyObject *__pyx_n_s_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_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_pf_3zoo_11board_games_9tictactoe_4envs_22get_done_winner_cython_get_done_winner_cython(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_board); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr); /* proto */ +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ +static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object); /* proto */ +static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_1; +static PyObject *__pyx_int_112105877; +static PyObject *__pyx_int_136983863; +static PyObject *__pyx_int_184977713; +static PyObject *__pyx_int_neg_1; +static PyObject *__pyx_tuple_; +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__20; +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__16; +static PyObject *__pyx_tuple__17; +static PyObject *__pyx_tuple__18; +static PyObject *__pyx_tuple__19; +static PyObject *__pyx_tuple__21; +static PyObject *__pyx_tuple__22; +static PyObject *__pyx_tuple__23; +static PyObject *__pyx_tuple__24; +static PyObject *__pyx_tuple__25; +static PyObject *__pyx_tuple__26; +static PyObject *__pyx_tuple__27; +static PyObject *__pyx_tuple__28; +static PyObject *__pyx_tuple__29; +static PyObject *__pyx_tuple__30; +static PyObject *__pyx_codeobj__31; +/* Late includes */ + +/* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":6 + * @cython.boundscheck(False) + * @cython.wraparound(False) + * cpdef get_done_winner_cython(int32_t[:, :] board): # <<<<<<<<<<<<<< + * """ + * Overview: + */ + +static PyObject *__pyx_pw_3zoo_11board_games_9tictactoe_4envs_22get_done_winner_cython_1get_done_winner_cython(PyObject *__pyx_self, PyObject *__pyx_arg_board); /*proto*/ +static PyObject *__pyx_f_3zoo_11board_games_9tictactoe_4envs_22get_done_winner_cython_get_done_winner_cython(__Pyx_memviewslice __pyx_v_board, CYTHON_UNUSED int __pyx_skip_dispatch) { + int32_t __pyx_v_i; + int32_t __pyx_v_j; + int32_t __pyx_v_player; + int32_t __pyx_v_x; + int32_t __pyx_v_y; + int32_t __pyx_v_count; + int __pyx_v_has_legal_actions; + PyObject *__pyx_v_directions = 0; + PyObject *__pyx_v_d = NULL; + CYTHON_UNUSED long __pyx_v__; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int32_t __pyx_t_1; + int32_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + Py_ssize_t __pyx_t_7; + PyObject *(*__pyx_t_8)(PyObject *); + PyObject *__pyx_t_9 = NULL; + int32_t __pyx_t_10; + int32_t __pyx_t_11; + long __pyx_t_12; + int __pyx_t_13; + PyObject *__pyx_t_14 = NULL; + PyObject *__pyx_t_15 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_done_winner_cython", 0); + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":20 + * """ + * cdef int32_t i, j, player, x, y, count + * cdef bint has_legal_actions = False # <<<<<<<<<<<<<< + * cdef directions = ((1, -1), (1, 0), (1, 1), (0, 1)) + * + */ + __pyx_v_has_legal_actions = 0; + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":21 + * cdef int32_t i, j, player, x, y, count + * cdef bint has_legal_actions = False + * cdef directions = ((1, -1), (1, 0), (1, 1), (0, 1)) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_INCREF(__pyx_tuple__5); + __pyx_v_directions = __pyx_tuple__5; + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":24 + * + * + * for i in range(3): # <<<<<<<<<<<<<< + * for j in range(3): + * if board[i, j] == 0: + */ + for (__pyx_t_1 = 0; __pyx_t_1 < 3; __pyx_t_1+=1) { + __pyx_v_i = __pyx_t_1; + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":25 + * + * for i in range(3): + * for j in range(3): # <<<<<<<<<<<<<< + * if board[i, j] == 0: + * has_legal_actions = True + */ + for (__pyx_t_2 = 0; __pyx_t_2 < 3; __pyx_t_2+=1) { + __pyx_v_j = __pyx_t_2; + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":26 + * for i in range(3): + * for j in range(3): + * if board[i, j] == 0: # <<<<<<<<<<<<<< + * has_legal_actions = True + * continue + */ + __pyx_t_3 = __pyx_v_i; + __pyx_t_4 = __pyx_v_j; + __pyx_t_5 = (((*((int32_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_board.data + __pyx_t_3 * __pyx_v_board.strides[0]) ) + __pyx_t_4 * __pyx_v_board.strides[1]) ))) == 0) != 0); + if (__pyx_t_5) { + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":27 + * for j in range(3): + * if board[i, j] == 0: + * has_legal_actions = True # <<<<<<<<<<<<<< + * continue + * player = board[i, j] + */ + __pyx_v_has_legal_actions = 1; + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":28 + * if board[i, j] == 0: + * has_legal_actions = True + * continue # <<<<<<<<<<<<<< + * player = board[i, j] + * for d in directions: + */ + goto __pyx_L5_continue; + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":26 + * for i in range(3): + * for j in range(3): + * if board[i, j] == 0: # <<<<<<<<<<<<<< + * has_legal_actions = True + * continue + */ + } + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":29 + * has_legal_actions = True + * continue + * player = board[i, j] # <<<<<<<<<<<<<< + * for d in directions: + * x, y = i, j + */ + __pyx_t_4 = __pyx_v_i; + __pyx_t_3 = __pyx_v_j; + __pyx_v_player = (*((int32_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_board.data + __pyx_t_4 * __pyx_v_board.strides[0]) ) + __pyx_t_3 * __pyx_v_board.strides[1]) ))); + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":30 + * continue + * player = board[i, j] + * for d in directions: # <<<<<<<<<<<<<< + * x, y = i, j + * count = 0 + */ + if (likely(PyList_CheckExact(__pyx_v_directions)) || PyTuple_CheckExact(__pyx_v_directions)) { + __pyx_t_6 = __pyx_v_directions; __Pyx_INCREF(__pyx_t_6); __pyx_t_7 = 0; + __pyx_t_8 = NULL; + } else { + __pyx_t_7 = -1; __pyx_t_6 = PyObject_GetIter(__pyx_v_directions); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 30, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = Py_TYPE(__pyx_t_6)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 30, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_8)) { + if (likely(PyList_CheckExact(__pyx_t_6))) { + if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_6)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_9 = PyList_GET_ITEM(__pyx_t_6, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 30, __pyx_L1_error) + #else + __pyx_t_9 = PySequence_ITEM(__pyx_t_6, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 30, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + } else { + if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_6)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_6, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(0, 30, __pyx_L1_error) + #else + __pyx_t_9 = PySequence_ITEM(__pyx_t_6, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 30, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + } + } else { + __pyx_t_9 = __pyx_t_8(__pyx_t_6); + 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(0, 30, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_9); + } + __Pyx_XDECREF_SET(__pyx_v_d, __pyx_t_9); + __pyx_t_9 = 0; + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":31 + * player = board[i, j] + * for d in directions: + * x, y = i, j # <<<<<<<<<<<<<< + * count = 0 + * for _ in range(5): + */ + __pyx_t_10 = __pyx_v_i; + __pyx_t_11 = __pyx_v_j; + __pyx_v_x = __pyx_t_10; + __pyx_v_y = __pyx_t_11; + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":32 + * for d in directions: + * x, y = i, j + * count = 0 # <<<<<<<<<<<<<< + * for _ in range(5): + * if x < 0 or x >= 3 or y < 0 or y >= 3: + */ + __pyx_v_count = 0; + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":33 + * x, y = i, j + * count = 0 + * for _ in range(5): # <<<<<<<<<<<<<< + * if x < 0 or x >= 3 or y < 0 or y >= 3: + * break + */ + for (__pyx_t_12 = 0; __pyx_t_12 < 5; __pyx_t_12+=1) { + __pyx_v__ = __pyx_t_12; + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":34 + * count = 0 + * for _ in range(5): + * if x < 0 or x >= 3 or y < 0 or y >= 3: # <<<<<<<<<<<<<< + * break + * if board[x, y] != player: + */ + __pyx_t_13 = ((__pyx_v_x < 0) != 0); + if (!__pyx_t_13) { + } else { + __pyx_t_5 = __pyx_t_13; + goto __pyx_L13_bool_binop_done; + } + __pyx_t_13 = ((__pyx_v_x >= 3) != 0); + if (!__pyx_t_13) { + } else { + __pyx_t_5 = __pyx_t_13; + goto __pyx_L13_bool_binop_done; + } + __pyx_t_13 = ((__pyx_v_y < 0) != 0); + if (!__pyx_t_13) { + } else { + __pyx_t_5 = __pyx_t_13; + goto __pyx_L13_bool_binop_done; + } + __pyx_t_13 = ((__pyx_v_y >= 3) != 0); + __pyx_t_5 = __pyx_t_13; + __pyx_L13_bool_binop_done:; + if (__pyx_t_5) { + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":35 + * for _ in range(5): + * if x < 0 or x >= 3 or y < 0 or y >= 3: + * break # <<<<<<<<<<<<<< + * if board[x, y] != player: + * break + */ + goto __pyx_L11_break; + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":34 + * count = 0 + * for _ in range(5): + * if x < 0 or x >= 3 or y < 0 or y >= 3: # <<<<<<<<<<<<<< + * break + * if board[x, y] != player: + */ + } + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":36 + * if x < 0 or x >= 3 or y < 0 or y >= 3: + * break + * if board[x, y] != player: # <<<<<<<<<<<<<< + * break + * x += d[0] + */ + __pyx_t_3 = __pyx_v_x; + __pyx_t_4 = __pyx_v_y; + __pyx_t_5 = (((*((int32_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_board.data + __pyx_t_3 * __pyx_v_board.strides[0]) ) + __pyx_t_4 * __pyx_v_board.strides[1]) ))) != __pyx_v_player) != 0); + if (__pyx_t_5) { + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":37 + * break + * if board[x, y] != player: + * break # <<<<<<<<<<<<<< + * x += d[0] + * y += d[1] + */ + goto __pyx_L11_break; + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":36 + * if x < 0 or x >= 3 or y < 0 or y >= 3: + * break + * if board[x, y] != player: # <<<<<<<<<<<<<< + * break + * x += d[0] + */ + } + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":38 + * if board[x, y] != player: + * break + * x += d[0] # <<<<<<<<<<<<<< + * y += d[1] + * count += 1 + */ + __pyx_t_9 = __Pyx_PyInt_From_int32_t(__pyx_v_x); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_14 = __Pyx_GetItemInt(__pyx_v_d, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_15 = PyNumber_InPlaceAdd(__pyx_t_9, __pyx_t_14); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __pyx_t_11 = __Pyx_PyInt_As_int32_t(__pyx_t_15); if (unlikely((__pyx_t_11 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 38, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __pyx_v_x = __pyx_t_11; + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":39 + * break + * x += d[0] + * y += d[1] # <<<<<<<<<<<<<< + * count += 1 + * if count == 5: + */ + __pyx_t_15 = __Pyx_PyInt_From_int32_t(__pyx_v_y); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __pyx_t_14 = __Pyx_GetItemInt(__pyx_v_d, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 0); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_9 = PyNumber_InPlaceAdd(__pyx_t_15, __pyx_t_14); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __pyx_t_11 = __Pyx_PyInt_As_int32_t(__pyx_t_9); if (unlikely((__pyx_t_11 == ((int32_t)-1)) && PyErr_Occurred())) __PYX_ERR(0, 39, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_y = __pyx_t_11; + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":40 + * x += d[0] + * y += d[1] + * count += 1 # <<<<<<<<<<<<<< + * if count == 5: + * return True, player + */ + __pyx_v_count = (__pyx_v_count + 1); + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":41 + * y += d[1] + * count += 1 + * if count == 5: # <<<<<<<<<<<<<< + * return True, player + * return not has_legal_actions, -1 + */ + __pyx_t_5 = ((__pyx_v_count == 5) != 0); + if (__pyx_t_5) { + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":42 + * count += 1 + * if count == 5: + * return True, player # <<<<<<<<<<<<<< + * return not has_legal_actions, -1 + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_9 = __Pyx_PyInt_From_int32_t(__pyx_v_player); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_14 = PyTuple_New(2); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 42, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_INCREF(Py_True); + __Pyx_GIVEREF(Py_True); + PyTuple_SET_ITEM(__pyx_t_14, 0, Py_True); + __Pyx_GIVEREF(__pyx_t_9); + PyTuple_SET_ITEM(__pyx_t_14, 1, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_r = __pyx_t_14; + __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L0; + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":41 + * y += d[1] + * count += 1 + * if count == 5: # <<<<<<<<<<<<<< + * return True, player + * return not has_legal_actions, -1 + */ + } + } + __pyx_L11_break:; + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":30 + * continue + * player = board[i, j] + * for d in directions: # <<<<<<<<<<<<<< + * x, y = i, j + * count = 0 + */ + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_L5_continue:; + } + } + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":43 + * if count == 5: + * return True, player + * return not has_legal_actions, -1 # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_6 = __Pyx_PyBool_FromLong((!(__pyx_v_has_legal_actions != 0))); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_14 = PyTuple_New(2); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 43, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_6); + __Pyx_INCREF(__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_int_neg_1); + PyTuple_SET_ITEM(__pyx_t_14, 1, __pyx_int_neg_1); + __pyx_t_6 = 0; + __pyx_r = __pyx_t_14; + __pyx_t_14 = 0; + goto __pyx_L0; + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":6 + * @cython.boundscheck(False) + * @cython.wraparound(False) + * cpdef get_done_winner_cython(int32_t[:, :] board): # <<<<<<<<<<<<<< + * """ + * Overview: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_AddTraceback("zoo.board_games.tictactoe.envs.get_done_winner_cython.get_done_winner_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_directions); + __Pyx_XDECREF(__pyx_v_d); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_3zoo_11board_games_9tictactoe_4envs_22get_done_winner_cython_1get_done_winner_cython(PyObject *__pyx_self, PyObject *__pyx_arg_board); /*proto*/ +static char __pyx_doc_3zoo_11board_games_9tictactoe_4envs_22get_done_winner_cython_get_done_winner_cython[] = "\n Overview:\n Check if the game is over and who the winner is. Return 'done' and 'winner'.\n Arguments:\n - board (:obj:`numpy.ndarray`): The board state.\n Returns:\n - outputs (:obj:`Tuple`): Tuple containing 'done' and 'winner',\n - if player 1 win, 'done' = True, 'winner' = 1\n - if player 2 win, 'done' = True, 'winner' = 2\n - if draw, 'done' = True, 'winner' = -1\n - if game is not over, 'done' = False, 'winner' = -1\n "; +static PyObject *__pyx_pw_3zoo_11board_games_9tictactoe_4envs_22get_done_winner_cython_1get_done_winner_cython(PyObject *__pyx_self, PyObject *__pyx_arg_board) { + __Pyx_memviewslice __pyx_v_board = { 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("get_done_winner_cython (wrapper)", 0); + assert(__pyx_arg_board); { + __pyx_v_board = __Pyx_PyObject_to_MemoryviewSlice_dsds_nn_int32_t(__pyx_arg_board, PyBUF_WRITABLE); if (unlikely(!__pyx_v_board.memview)) __PYX_ERR(0, 6, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("zoo.board_games.tictactoe.envs.get_done_winner_cython.get_done_winner_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3zoo_11board_games_9tictactoe_4envs_22get_done_winner_cython_get_done_winner_cython(__pyx_self, __pyx_v_board); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_3zoo_11board_games_9tictactoe_4envs_22get_done_winner_cython_get_done_winner_cython(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_board) { + 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_done_winner_cython", 0); + __Pyx_XDECREF(__pyx_r); + if (unlikely(!__pyx_v_board.memview)) { __Pyx_RaiseUnboundLocalError("board"); __PYX_ERR(0, 6, __pyx_L1_error) } + __pyx_t_1 = __pyx_f_3zoo_11board_games_9tictactoe_4envs_22get_done_winner_cython_get_done_winner_cython(__pyx_v_board, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __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("zoo.board_games.tictactoe.envs.get_done_winner_cython.get_done_winner_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __PYX_XDEC_MEMVIEW(&__pyx_v_board, 1); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":123 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): + * + */ + +/* Python wrapper */ +static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_shape = 0; + Py_ssize_t __pyx_v_itemsize; + PyObject *__pyx_v_format = 0; + PyObject *__pyx_v_mode = 0; + int __pyx_v_allocate_buffer; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shape,&__pyx_n_s_itemsize,&__pyx_n_s_format,&__pyx_n_s_mode,&__pyx_n_s_allocate_buffer,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[3] = ((PyObject *)__pyx_n_s_c); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shape)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_itemsize)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(1, 123, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_format)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(1, 123, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_allocate_buffer); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 123, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_shape = ((PyObject*)values[0]); + __pyx_v_itemsize = __Pyx_PyIndex_AsSsize_t(values[1]); if (unlikely((__pyx_v_itemsize == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 123, __pyx_L3_error) + __pyx_v_format = values[2]; + __pyx_v_mode = values[3]; + if (values[4]) { + __pyx_v_allocate_buffer = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_allocate_buffer == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 124, __pyx_L3_error) + } else { + + /* "View.MemoryView":124 + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, + * mode="c", bint allocate_buffer=True): # <<<<<<<<<<<<<< + * + * cdef int idx + */ + __pyx_v_allocate_buffer = ((int)1); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 123, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_shape), (&PyTuple_Type), 1, "shape", 1))) __PYX_ERR(1, 123, __pyx_L1_error) + if (unlikely(((PyObject *)__pyx_v_format) == Py_None)) { + PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "format"); __PYX_ERR(1, 123, __pyx_L1_error) + } + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v_shape, __pyx_v_itemsize, __pyx_v_format, __pyx_v_mode, __pyx_v_allocate_buffer); + + /* "View.MemoryView":123 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): + * + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer) { + int __pyx_v_idx; + Py_ssize_t __pyx_v_i; + Py_ssize_t __pyx_v_dim; + PyObject **__pyx_v_p; + char __pyx_v_order; + int __pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + char *__pyx_t_7; + int __pyx_t_8; + Py_ssize_t __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + Py_ssize_t __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + __Pyx_INCREF(__pyx_v_format); + + /* "View.MemoryView":130 + * cdef PyObject **p + * + * self.ndim = len(shape) # <<<<<<<<<<<<<< + * self.itemsize = itemsize + * + */ + if (unlikely(__pyx_v_shape == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 130, __pyx_L1_error) + } + __pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 130, __pyx_L1_error) + __pyx_v_self->ndim = ((int)__pyx_t_1); + + /* "View.MemoryView":131 + * + * self.ndim = len(shape) + * self.itemsize = itemsize # <<<<<<<<<<<<<< + * + * if not self.ndim: + */ + __pyx_v_self->itemsize = __pyx_v_itemsize; + + /* "View.MemoryView":133 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError("Empty shape tuple for cython.array") + * + */ + __pyx_t_2 = ((!(__pyx_v_self->ndim != 0)) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":134 + * + * if not self.ndim: + * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< + * + * if itemsize <= 0: + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 134, __pyx_L1_error) + + /* "View.MemoryView":133 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError("Empty shape tuple for cython.array") + * + */ + } + + /* "View.MemoryView":136 + * raise ValueError("Empty shape tuple for cython.array") + * + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError("itemsize <= 0 for cython.array") + * + */ + __pyx_t_2 = ((__pyx_v_itemsize <= 0) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":137 + * + * if itemsize <= 0: + * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< + * + * if not isinstance(format, bytes): + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 137, __pyx_L1_error) + + /* "View.MemoryView":136 + * raise ValueError("Empty shape tuple for cython.array") + * + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError("itemsize <= 0 for cython.array") + * + */ + } + + /* "View.MemoryView":139 + * raise ValueError("itemsize <= 0 for cython.array") + * + * if not isinstance(format, bytes): # <<<<<<<<<<<<<< + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string + */ + __pyx_t_2 = PyBytes_Check(__pyx_v_format); + __pyx_t_4 = ((!(__pyx_t_2 != 0)) != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":140 + * + * if not isinstance(format, bytes): + * format = format.encode('ASCII') # <<<<<<<<<<<<<< + * self._format = format # keep a reference to the byte string + * self.format = self._format + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_n_s_ASCII) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_n_s_ASCII); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":139 + * raise ValueError("itemsize <= 0 for cython.array") + * + * if not isinstance(format, bytes): # <<<<<<<<<<<<<< + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string + */ + } + + /* "View.MemoryView":141 + * if not isinstance(format, bytes): + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string # <<<<<<<<<<<<<< + * self.format = self._format + * + */ + if (!(likely(PyBytes_CheckExact(__pyx_v_format))||((__pyx_v_format) == Py_None)||((void)PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v_format)->tp_name), 0))) __PYX_ERR(1, 141, __pyx_L1_error) + __pyx_t_3 = __pyx_v_format; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->_format); + __Pyx_DECREF(__pyx_v_self->_format); + __pyx_v_self->_format = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":142 + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string + * self.format = self._format # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(__pyx_v_self->_format == Py_None)) { + PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); + __PYX_ERR(1, 142, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(1, 142, __pyx_L1_error) + __pyx_v_self->format = __pyx_t_7; + + /* "View.MemoryView":145 + * + * + * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) # <<<<<<<<<<<<<< + * self._strides = self._shape + self.ndim + * + */ + __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2))); + + /* "View.MemoryView":146 + * + * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) + * self._strides = self._shape + self.ndim # <<<<<<<<<<<<<< + * + * if not self._shape: + */ + __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim); + + /* "View.MemoryView":148 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate shape and strides.") + * + */ + __pyx_t_4 = ((!(__pyx_v_self->_shape != 0)) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":149 + * + * if not self._shape: + * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 149, __pyx_L1_error) + + /* "View.MemoryView":148 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate shape and strides.") + * + */ + } + + /* "View.MemoryView":152 + * + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + */ + __pyx_t_8 = 0; + __pyx_t_3 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0; + for (;;) { + if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(1, 152, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 152, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_dim = __pyx_t_9; + __pyx_v_idx = __pyx_t_8; + __pyx_t_8 = (__pyx_t_8 + 1); + + /* "View.MemoryView":153 + * + * for idx, dim in enumerate(shape): + * if dim <= 0: # <<<<<<<<<<<<<< + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim + */ + __pyx_t_4 = ((__pyx_v_dim <= 0) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":154 + * for idx, dim in enumerate(shape): + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) # <<<<<<<<<<<<<< + * self._shape[idx] = dim + * + */ + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_6); + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 154, __pyx_L1_error) + + /* "View.MemoryView":153 + * + * for idx, dim in enumerate(shape): + * if dim <= 0: # <<<<<<<<<<<<<< + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim + */ + } + + /* "View.MemoryView":155 + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim # <<<<<<<<<<<<<< + * + * cdef char order + */ + (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim; + + /* "View.MemoryView":152 + * + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":158 + * + * cdef char order + * if mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' + */ + __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 158, __pyx_L1_error) + if (__pyx_t_4) { + + /* "View.MemoryView":159 + * cdef char order + * if mode == 'fortran': + * order = b'F' # <<<<<<<<<<<<<< + * self.mode = u'fortran' + * elif mode == 'c': + */ + __pyx_v_order = 'F'; + + /* "View.MemoryView":160 + * if mode == 'fortran': + * order = b'F' + * self.mode = u'fortran' # <<<<<<<<<<<<<< + * elif mode == 'c': + * order = b'C' + */ + __Pyx_INCREF(__pyx_n_u_fortran); + __Pyx_GIVEREF(__pyx_n_u_fortran); + __Pyx_GOTREF(__pyx_v_self->mode); + __Pyx_DECREF(__pyx_v_self->mode); + __pyx_v_self->mode = __pyx_n_u_fortran; + + /* "View.MemoryView":158 + * + * cdef char order + * if mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' + */ + goto __pyx_L10; + } + + /* "View.MemoryView":161 + * order = b'F' + * self.mode = u'fortran' + * elif mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' + */ + __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_c, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 161, __pyx_L1_error) + if (likely(__pyx_t_4)) { + + /* "View.MemoryView":162 + * self.mode = u'fortran' + * elif mode == 'c': + * order = b'C' # <<<<<<<<<<<<<< + * self.mode = u'c' + * else: + */ + __pyx_v_order = 'C'; + + /* "View.MemoryView":163 + * elif mode == 'c': + * order = b'C' + * self.mode = u'c' # <<<<<<<<<<<<<< + * else: + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) + */ + __Pyx_INCREF(__pyx_n_u_c); + __Pyx_GIVEREF(__pyx_n_u_c); + __Pyx_GOTREF(__pyx_v_self->mode); + __Pyx_DECREF(__pyx_v_self->mode); + __pyx_v_self->mode = __pyx_n_u_c; + + /* "View.MemoryView":161 + * order = b'F' + * self.mode = u'fortran' + * elif mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' + */ + goto __pyx_L10; + } + + /* "View.MemoryView":165 + * self.mode = u'c' + * else: + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) # <<<<<<<<<<<<<< + * + * self.len = fill_contig_strides_array(self._shape, self._strides, + */ + /*else*/ { + __pyx_t_3 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_v_mode); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 165, __pyx_L1_error) + } + __pyx_L10:; + + /* "View.MemoryView":167 + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) + * + * self.len = fill_contig_strides_array(self._shape, self._strides, # <<<<<<<<<<<<<< + * itemsize, self.ndim, order) + * + */ + __pyx_v_self->len = __pyx_fill_contig_strides_array(__pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_itemsize, __pyx_v_self->ndim, __pyx_v_order); + + /* "View.MemoryView":170 + * itemsize, self.ndim, order) + * + * self.free_data = allocate_buffer # <<<<<<<<<<<<<< + * self.dtype_is_object = format == b'O' + * if allocate_buffer: + */ + __pyx_v_self->free_data = __pyx_v_allocate_buffer; + + /* "View.MemoryView":171 + * + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<< + * if allocate_buffer: + * + */ + __pyx_t_10 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 171, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 171, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_v_self->dtype_is_object = __pyx_t_4; + + /* "View.MemoryView":172 + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' + * if allocate_buffer: # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = (__pyx_v_allocate_buffer != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":175 + * + * + * self.data = malloc(self.len) # <<<<<<<<<<<<<< + * if not self.data: + * raise MemoryError("unable to allocate array data.") + */ + __pyx_v_self->data = ((char *)malloc(__pyx_v_self->len)); + + /* "View.MemoryView":176 + * + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate array data.") + * + */ + __pyx_t_4 = ((!(__pyx_v_self->data != 0)) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":177 + * self.data = malloc(self.len) + * if not self.data: + * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< + * + * if self.dtype_is_object: + */ + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 177, __pyx_L1_error) + + /* "View.MemoryView":176 + * + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate array data.") + * + */ + } + + /* "View.MemoryView":179 + * raise MemoryError("unable to allocate array data.") + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len / itemsize): + */ + __pyx_t_4 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":180 + * + * if self.dtype_is_object: + * p = self.data # <<<<<<<<<<<<<< + * for i in range(self.len / itemsize): + * p[i] = Py_None + */ + __pyx_v_p = ((PyObject **)__pyx_v_self->data); + + /* "View.MemoryView":181 + * if self.dtype_is_object: + * p = self.data + * for i in range(self.len / itemsize): # <<<<<<<<<<<<<< + * p[i] = Py_None + * Py_INCREF(Py_None) + */ + if (unlikely(__pyx_v_itemsize == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); + __PYX_ERR(1, 181, __pyx_L1_error) + } + else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) { + PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); + __PYX_ERR(1, 181, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_itemsize); + __pyx_t_9 = __pyx_t_1; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_9; __pyx_t_11+=1) { + __pyx_v_i = __pyx_t_11; + + /* "View.MemoryView":182 + * p = self.data + * for i in range(self.len / itemsize): + * p[i] = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * + */ + (__pyx_v_p[__pyx_v_i]) = Py_None; + + /* "View.MemoryView":183 + * for i in range(self.len / itemsize): + * p[i] = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + Py_INCREF(Py_None); + } + + /* "View.MemoryView":179 + * raise MemoryError("unable to allocate array data.") + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len / itemsize): + */ + } + + /* "View.MemoryView":172 + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' + * if allocate_buffer: # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":123 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_format); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":186 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * cdef int bufmode = -1 + * if self.mode == u"c": + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(((struct __pyx_array_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_bufmode; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + char *__pyx_t_4; + Py_ssize_t __pyx_t_5; + int __pyx_t_6; + Py_ssize_t *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + if (__pyx_v_info == NULL) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + + /* "View.MemoryView":187 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 # <<<<<<<<<<<<<< + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + */ + __pyx_v_bufmode = -1; + + /* "View.MemoryView":188 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + */ + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_c, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 188, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":189 + * cdef int bufmode = -1 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + */ + __pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); + + /* "View.MemoryView":188 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + */ + goto __pyx_L3; + } + + /* "View.MemoryView":190 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": # <<<<<<<<<<<<<< + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + */ + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 190, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":191 + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") + */ + __pyx_v_bufmode = (PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); + + /* "View.MemoryView":190 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": # <<<<<<<<<<<<<< + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + */ + } + __pyx_L3:; + + /* "View.MemoryView":192 + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): # <<<<<<<<<<<<<< + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data + */ + __pyx_t_1 = ((!((__pyx_v_flags & __pyx_v_bufmode) != 0)) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":193 + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") # <<<<<<<<<<<<<< + * info.buf = self.data + * info.len = self.len + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 193, __pyx_L1_error) + + /* "View.MemoryView":192 + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): # <<<<<<<<<<<<<< + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data + */ + } + + /* "View.MemoryView":194 + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data # <<<<<<<<<<<<<< + * info.len = self.len + * info.ndim = self.ndim + */ + __pyx_t_4 = __pyx_v_self->data; + __pyx_v_info->buf = __pyx_t_4; + + /* "View.MemoryView":195 + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data + * info.len = self.len # <<<<<<<<<<<<<< + * info.ndim = self.ndim + * info.shape = self._shape + */ + __pyx_t_5 = __pyx_v_self->len; + __pyx_v_info->len = __pyx_t_5; + + /* "View.MemoryView":196 + * info.buf = self.data + * info.len = self.len + * info.ndim = self.ndim # <<<<<<<<<<<<<< + * info.shape = self._shape + * info.strides = self._strides + */ + __pyx_t_6 = __pyx_v_self->ndim; + __pyx_v_info->ndim = __pyx_t_6; + + /* "View.MemoryView":197 + * info.len = self.len + * info.ndim = self.ndim + * info.shape = self._shape # <<<<<<<<<<<<<< + * info.strides = self._strides + * info.suboffsets = NULL + */ + __pyx_t_7 = __pyx_v_self->_shape; + __pyx_v_info->shape = __pyx_t_7; + + /* "View.MemoryView":198 + * info.ndim = self.ndim + * info.shape = self._shape + * info.strides = self._strides # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = self.itemsize + */ + __pyx_t_7 = __pyx_v_self->_strides; + __pyx_v_info->strides = __pyx_t_7; + + /* "View.MemoryView":199 + * info.shape = self._shape + * info.strides = self._strides + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = self.itemsize + * info.readonly = 0 + */ + __pyx_v_info->suboffsets = NULL; + + /* "View.MemoryView":200 + * info.strides = self._strides + * info.suboffsets = NULL + * info.itemsize = self.itemsize # <<<<<<<<<<<<<< + * info.readonly = 0 + * + */ + __pyx_t_5 = __pyx_v_self->itemsize; + __pyx_v_info->itemsize = __pyx_t_5; + + /* "View.MemoryView":201 + * info.suboffsets = NULL + * info.itemsize = self.itemsize + * info.readonly = 0 # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + __pyx_v_info->readonly = 0; + + /* "View.MemoryView":203 + * info.readonly = 0 + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.format + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":204 + * + * if flags & PyBUF_FORMAT: + * info.format = self.format # <<<<<<<<<<<<<< + * else: + * info.format = NULL + */ + __pyx_t_4 = __pyx_v_self->format; + __pyx_v_info->format = __pyx_t_4; + + /* "View.MemoryView":203 + * info.readonly = 0 + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.format + * else: + */ + goto __pyx_L5; + } + + /* "View.MemoryView":206 + * info.format = self.format + * else: + * info.format = NULL # <<<<<<<<<<<<<< + * + * info.obj = self + */ + /*else*/ { + __pyx_v_info->format = NULL; + } + __pyx_L5:; + + /* "View.MemoryView":208 + * info.format = NULL + * + * info.obj = self # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + */ + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + + /* "View.MemoryView":186 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * cdef int bufmode = -1 + * if self.mode == u"c": + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.array.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":212 + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + * + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + */ + +/* Python wrapper */ +static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_array___dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":213 + * + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data: + */ + __pyx_t_1 = ((__pyx_v_self->callback_free_data != NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":214 + * def __dealloc__(array self): + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) # <<<<<<<<<<<<<< + * elif self.free_data: + * if self.dtype_is_object: + */ + __pyx_v_self->callback_free_data(__pyx_v_self->data); + + /* "View.MemoryView":213 + * + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":215 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, + */ + __pyx_t_1 = (__pyx_v_self->free_data != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":216 + * self.callback_free_data(self.data) + * elif self.free_data: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + */ + __pyx_t_1 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":217 + * elif self.free_data: + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, # <<<<<<<<<<<<<< + * self._strides, self.ndim, False) + * free(self.data) + */ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_self->data, __pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_self->ndim, 0); + + /* "View.MemoryView":216 + * self.callback_free_data(self.data) + * elif self.free_data: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + */ + } + + /* "View.MemoryView":219 + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + * free(self.data) # <<<<<<<<<<<<<< + * PyObject_Free(self._shape) + * + */ + free(__pyx_v_self->data); + + /* "View.MemoryView":215 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, + */ + } + __pyx_L3:; + + /* "View.MemoryView":220 + * self._strides, self.ndim, False) + * free(self.data) + * PyObject_Free(self._shape) # <<<<<<<<<<<<<< + * + * @property + */ + PyObject_Free(__pyx_v_self->_shape); + + /* "View.MemoryView":212 + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + * + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":223 + * + * @property + * def memview(self): # <<<<<<<<<<<<<< + * return self.get_memview() + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_5array_7memview___get__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":224 + * @property + * def memview(self): + * return self.get_memview() # <<<<<<<<<<<<<< + * + * @cname('get_memview') + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_array *)__pyx_v_self->__pyx_vtab)->get_memview(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":223 + * + * @property + * def memview(self): # <<<<<<<<<<<<<< + * return self.get_memview() + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.memview.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":227 + * + * @cname('get_memview') + * cdef get_memview(self): # <<<<<<<<<<<<<< + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) + */ + +static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) { + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_memview", 0); + + /* "View.MemoryView":228 + * @cname('get_memview') + * cdef get_memview(self): + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE # <<<<<<<<<<<<<< + * return memoryview(self, flags, self.dtype_is_object) + * + */ + __pyx_v_flags = ((PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) | PyBUF_WRITABLE); + + /* "View.MemoryView":229 + * cdef get_memview(self): + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) # <<<<<<<<<<<<<< + * + * def __len__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":227 + * + * @cname('get_memview') + * cdef get_memview(self): # <<<<<<<<<<<<<< + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.array.get_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":231 + * return memoryview(self, flags, self.dtype_is_object) + * + * def __len__(self): # <<<<<<<<<<<<<< + * return self._shape[0] + * + */ + +/* Python wrapper */ +static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self); /*proto*/ +static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__", 0); + + /* "View.MemoryView":232 + * + * def __len__(self): + * return self._shape[0] # <<<<<<<<<<<<<< + * + * def __getattr__(self, attr): + */ + __pyx_r = (__pyx_v_self->_shape[0]); + goto __pyx_L0; + + /* "View.MemoryView":231 + * return memoryview(self, flags, self.dtype_is_object) + * + * def __len__(self): # <<<<<<<<<<<<<< + * return self._shape[0] + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":234 + * return self._shape[0] + * + * def __getattr__(self, attr): # <<<<<<<<<<<<<< + * return getattr(self.memview, attr) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr); /*proto*/ +static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_attr)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getattr__", 0); + + /* "View.MemoryView":235 + * + * def __getattr__(self, attr): + * return getattr(self.memview, attr) # <<<<<<<<<<<<<< + * + * def __getitem__(self, item): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_GetAttr(__pyx_t_1, __pyx_v_attr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":234 + * return self._shape[0] + * + * def __getattr__(self, attr): # <<<<<<<<<<<<<< + * return getattr(self.memview, attr) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.array.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":237 + * return getattr(self.memview, attr) + * + * def __getitem__(self, item): # <<<<<<<<<<<<<< + * return self.memview[item] + * + */ + +/* Python wrapper */ +static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/ +static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "View.MemoryView":238 + * + * def __getitem__(self, item): + * return self.memview[item] # <<<<<<<<<<<<<< + * + * def __setitem__(self, item, value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":237 + * return getattr(self.memview, attr) + * + * def __getitem__(self, item): # <<<<<<<<<<<<<< + * return self.memview[item] + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":240 + * return self.memview[item] + * + * def __setitem__(self, item, value): # <<<<<<<<<<<<<< + * self.memview[item] = value + * + */ + +/* Python wrapper */ +static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + + /* "View.MemoryView":241 + * + * def __setitem__(self, item, value): + * self.memview[item] = value # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_item, __pyx_v_value) < 0)) __PYX_ERR(1, 241, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":240 + * return self.memview[item] + * + * def __setitem__(self, item, value): # <<<<<<<<<<<<<< + * self.memview[item] = value + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__11, 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__12, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":245 + * + * @cname("__pyx_array_new") + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< + * char *mode, char *buf): + * cdef array result + */ + +static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, char *__pyx_v_format, char *__pyx_v_mode, char *__pyx_v_buf) { + struct __pyx_array_obj *__pyx_v_result = 0; + struct __pyx_array_obj *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("array_cwrapper", 0); + + /* "View.MemoryView":249 + * cdef array result + * + * if buf == NULL: # <<<<<<<<<<<<<< + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + */ + __pyx_t_1 = ((__pyx_v_buf == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":250 + * + * if buf == NULL: + * result = array(shape, itemsize, format, mode.decode('ASCII')) # <<<<<<<<<<<<<< + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), + */ + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_shape); + __Pyx_GIVEREF(__pyx_v_shape); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_shape); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":249 + * cdef array result + * + * if buf == NULL: # <<<<<<<<<<<<<< + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":252 + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< + * allocate_buffer=False) + * result.data = buf + */ + /*else*/ { + __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_shape); + __Pyx_GIVEREF(__pyx_v_shape); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_shape); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_3 = 0; + + /* "View.MemoryView":253 + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), + * allocate_buffer=False) # <<<<<<<<<<<<<< + * result.data = buf + * + */ + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 253, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(1, 253, __pyx_L1_error) + + /* "View.MemoryView":252 + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< + * allocate_buffer=False) + * result.data = buf + */ + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_5); + __pyx_t_5 = 0; + + /* "View.MemoryView":254 + * result = array(shape, itemsize, format, mode.decode('ASCII'), + * allocate_buffer=False) + * result.data = buf # <<<<<<<<<<<<<< + * + * return result + */ + __pyx_v_result->data = __pyx_v_buf; + } + __pyx_L3:; + + /* "View.MemoryView":256 + * result.data = buf + * + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "View.MemoryView":245 + * + * @cname("__pyx_array_new") + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< + * char *mode, char *buf): + * cdef array result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":282 + * cdef class Enum(object): + * cdef object name + * def __init__(self, name): # <<<<<<<<<<<<<< + * self.name = name + * def __repr__(self): + */ + +/* Python wrapper */ +static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_name = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 282, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_name = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 282, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.Enum.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v_name); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__", 0); + + /* "View.MemoryView":283 + * cdef object name + * def __init__(self, name): + * self.name = name # <<<<<<<<<<<<<< + * def __repr__(self): + * return self.name + */ + __Pyx_INCREF(__pyx_v_name); + __Pyx_GIVEREF(__pyx_v_name); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = __pyx_v_name; + + /* "View.MemoryView":282 + * cdef class Enum(object): + * cdef object name + * def __init__(self, name): # <<<<<<<<<<<<<< + * self.name = name + * def __repr__(self): + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":284 + * def __init__(self, name): + * self.name = name + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name + * + */ + +/* Python wrapper */ +static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "View.MemoryView":285 + * self.name = name + * def __repr__(self): + * return self.name # <<<<<<<<<<<<<< + * + * cdef generic = Enum("") + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->name); + __pyx_r = __pyx_v_self->name; + goto __pyx_L0; + + /* "View.MemoryView":284 + * def __init__(self, name): + * self.name = name + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_MemviewEnum___reduce_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.name,) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->name); + __Pyx_GIVEREF(__pyx_v_self->name); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict); + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.name is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.name is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + */ + /*else*/ { + __pyx_t_3 = (__pyx_v_self->name != Py_None); + __pyx_v_use_setstate = __pyx_t_3; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + */ + __pyx_t_3 = (__pyx_v_use_setstate != 0); + if (__pyx_t_3) { + + /* "(tree fragment)":13 + * use_setstate = self.name is not None + * if use_setstate: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_INCREF(__pyx_int_184977713); + __Pyx_GIVEREF(__pyx_int_184977713); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Enum__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_INCREF(__pyx_int_184977713); + __Pyx_GIVEREF(__pyx_int_184977713); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.Enum.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Enum__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||((void)PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_unpickle_Enum__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":299 + * + * @cname('__pyx_align_pointer') + * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory + */ + +static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) { + Py_intptr_t __pyx_v_aligned_p; + size_t __pyx_v_offset; + void *__pyx_r; + int __pyx_t_1; + + /* "View.MemoryView":301 + * cdef void *align_pointer(void *memory, size_t alignment) nogil: + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory # <<<<<<<<<<<<<< + * cdef size_t offset + * + */ + __pyx_v_aligned_p = ((Py_intptr_t)__pyx_v_memory); + + /* "View.MemoryView":305 + * + * with cython.cdivision(True): + * offset = aligned_p % alignment # <<<<<<<<<<<<<< + * + * if offset > 0: + */ + __pyx_v_offset = (__pyx_v_aligned_p % __pyx_v_alignment); + + /* "View.MemoryView":307 + * offset = aligned_p % alignment + * + * if offset > 0: # <<<<<<<<<<<<<< + * aligned_p += alignment - offset + * + */ + __pyx_t_1 = ((__pyx_v_offset > 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":308 + * + * if offset > 0: + * aligned_p += alignment - offset # <<<<<<<<<<<<<< + * + * return aligned_p + */ + __pyx_v_aligned_p = (__pyx_v_aligned_p + (__pyx_v_alignment - __pyx_v_offset)); + + /* "View.MemoryView":307 + * offset = aligned_p % alignment + * + * if offset > 0: # <<<<<<<<<<<<<< + * aligned_p += alignment - offset + * + */ + } + + /* "View.MemoryView":310 + * aligned_p += alignment - offset + * + * return aligned_p # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((void *)__pyx_v_aligned_p); + goto __pyx_L0; + + /* "View.MemoryView":299 + * + * @cname('__pyx_align_pointer') + * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":346 + * cdef __Pyx_TypeInfo *typeinfo + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< + * self.obj = obj + * self.flags = flags + */ + +/* Python wrapper */ +static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_obj = 0; + int __pyx_v_flags; + int __pyx_v_dtype_is_object; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_obj)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 346, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dtype_is_object); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 346, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_obj = values[0]; + __pyx_v_flags = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 346, __pyx_L3_error) + if (values[2]) { + __pyx_v_dtype_is_object = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_dtype_is_object == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 346, __pyx_L3_error) + } else { + __pyx_v_dtype_is_object = ((int)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 346, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_obj, __pyx_v_flags, __pyx_v_dtype_is_object); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "View.MemoryView":347 + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): + * self.obj = obj # <<<<<<<<<<<<<< + * self.flags = flags + * if type(self) is memoryview or obj is not None: + */ + __Pyx_INCREF(__pyx_v_obj); + __Pyx_GIVEREF(__pyx_v_obj); + __Pyx_GOTREF(__pyx_v_self->obj); + __Pyx_DECREF(__pyx_v_self->obj); + __pyx_v_self->obj = __pyx_v_obj; + + /* "View.MemoryView":348 + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): + * self.obj = obj + * self.flags = flags # <<<<<<<<<<<<<< + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) + */ + __pyx_v_self->flags = __pyx_v_flags; + + /* "View.MemoryView":349 + * self.obj = obj + * self.flags = flags + * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: + */ + __pyx_t_2 = (((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))) == ((PyObject *)__pyx_memoryview_type)); + __pyx_t_3 = (__pyx_t_2 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = (__pyx_v_obj != Py_None); + __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "View.MemoryView":350 + * self.flags = flags + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) # <<<<<<<<<<<<<< + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None + */ + __pyx_t_4 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 350, __pyx_L1_error) + + /* "View.MemoryView":351 + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) + */ + __pyx_t_1 = ((((PyObject *)__pyx_v_self->view.obj) == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":352 + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * + */ + ((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None; + + /* "View.MemoryView":353 + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + */ + Py_INCREF(Py_None); + + /* "View.MemoryView":351 + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) + */ + } + + /* "View.MemoryView":349 + * self.obj = obj + * self.flags = flags + * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: + */ + } + + /* "View.MemoryView":355 + * Py_INCREF(Py_None) + * + * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + */ + __pyx_t_1 = ((!(__PYX_CYTHON_ATOMICS_ENABLED() != 0)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":357 + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + */ + __pyx_t_1 = ((__pyx_memoryview_thread_locks_used < 8) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":358 + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: + */ + __pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); + + /* "View.MemoryView":359 + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 # <<<<<<<<<<<<<< + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + */ + __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1); + + /* "View.MemoryView":357 + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + */ + } + + /* "View.MemoryView":360 + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: # <<<<<<<<<<<<<< + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + */ + __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":361 + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() # <<<<<<<<<<<<<< + * if self.lock is NULL: + * raise MemoryError + */ + __pyx_v_self->lock = PyThread_allocate_lock(); + + /* "View.MemoryView":362 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * + */ + __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":363 + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + PyErr_NoMemory(); __PYX_ERR(1, 363, __pyx_L1_error) + + /* "View.MemoryView":362 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * + */ + } + + /* "View.MemoryView":360 + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: # <<<<<<<<<<<<<< + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + */ + } + + /* "View.MemoryView":355 + * Py_INCREF(Py_None) + * + * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + */ + } + + /* "View.MemoryView":365 + * raise MemoryError + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":366 + * + * if flags & PyBUF_FORMAT: + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') # <<<<<<<<<<<<<< + * else: + * self.dtype_is_object = dtype_is_object + */ + __pyx_t_2 = (((__pyx_v_self->view.format[0]) == 'O') != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L12_bool_binop_done; + } + __pyx_t_2 = (((__pyx_v_self->view.format[1]) == '\x00') != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L12_bool_binop_done:; + __pyx_v_self->dtype_is_object = __pyx_t_1; + + /* "View.MemoryView":365 + * raise MemoryError + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: + */ + goto __pyx_L11; + } + + /* "View.MemoryView":368 + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: + * self.dtype_is_object = dtype_is_object # <<<<<<<<<<<<<< + * + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( + */ + /*else*/ { + __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object; + } + __pyx_L11:; + + /* "View.MemoryView":370 + * self.dtype_is_object = dtype_is_object + * + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( # <<<<<<<<<<<<<< + * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) + * self.typeinfo = NULL + */ + __pyx_v_self->acquisition_count_aligned_p = ((__pyx_atomic_int *)__pyx_align_pointer(((void *)(&(__pyx_v_self->acquisition_count[0]))), (sizeof(__pyx_atomic_int)))); + + /* "View.MemoryView":372 + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( + * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) + * self.typeinfo = NULL # <<<<<<<<<<<<<< + * + * def __dealloc__(memoryview self): + */ + __pyx_v_self->typeinfo = NULL; + + /* "View.MemoryView":346 + * cdef __Pyx_TypeInfo *typeinfo + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< + * self.obj = obj + * self.flags = flags + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":374 + * self.typeinfo = NULL + * + * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + */ + +/* Python wrapper */ +static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self) { + int __pyx_v_i; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyThread_type_lock __pyx_t_6; + PyThread_type_lock __pyx_t_7; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":375 + * + * def __dealloc__(memoryview self): + * if self.obj is not None: # <<<<<<<<<<<<<< + * __Pyx_ReleaseBuffer(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + */ + __pyx_t_1 = (__pyx_v_self->obj != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":376 + * def __dealloc__(memoryview self): + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) # <<<<<<<<<<<<<< + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + * + */ + __Pyx_ReleaseBuffer((&__pyx_v_self->view)); + + /* "View.MemoryView":375 + * + * def __dealloc__(memoryview self): + * if self.obj is not None: # <<<<<<<<<<<<<< + * __Pyx_ReleaseBuffer(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":377 + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< + * + * (<__pyx_buffer *> &self.view).obj = NULL + */ + __pyx_t_2 = ((((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":379 + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + * + * (<__pyx_buffer *> &self.view).obj = NULL # <<<<<<<<<<<<<< + * Py_DECREF(Py_None) + * + */ + ((Py_buffer *)(&__pyx_v_self->view))->obj = NULL; + + /* "View.MemoryView":380 + * + * (<__pyx_buffer *> &self.view).obj = NULL + * Py_DECREF(Py_None) # <<<<<<<<<<<<<< + * + * cdef int i + */ + Py_DECREF(Py_None); + + /* "View.MemoryView":377 + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< + * + * (<__pyx_buffer *> &self.view).obj = NULL + */ + } + __pyx_L3:; + + /* "View.MemoryView":384 + * cdef int i + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: # <<<<<<<<<<<<<< + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: + */ + __pyx_t_2 = ((__pyx_v_self->lock != NULL) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":385 + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: + * for i in range(__pyx_memoryview_thread_locks_used): # <<<<<<<<<<<<<< + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + */ + __pyx_t_3 = __pyx_memoryview_thread_locks_used; + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "View.MemoryView":386 + * if self.lock != NULL: + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + */ + __pyx_t_2 = (((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":387 + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 # <<<<<<<<<<<<<< + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + */ + __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used - 1); + + /* "View.MemoryView":388 + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + */ + __pyx_t_2 = ((__pyx_v_i != __pyx_memoryview_thread_locks_used) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":390 + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) # <<<<<<<<<<<<<< + * break + * else: + */ + __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); + __pyx_t_7 = (__pyx_memoryview_thread_locks[__pyx_v_i]); + + /* "View.MemoryView":389 + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + * break + */ + (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_6; + (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_7; + + /* "View.MemoryView":388 + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + */ + } + + /* "View.MemoryView":391 + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + * break # <<<<<<<<<<<<<< + * else: + * PyThread_free_lock(self.lock) + */ + goto __pyx_L6_break; + + /* "View.MemoryView":386 + * if self.lock != NULL: + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + */ + } + } + /*else*/ { + + /* "View.MemoryView":393 + * break + * else: + * PyThread_free_lock(self.lock) # <<<<<<<<<<<<<< + * + * cdef char *get_item_pointer(memoryview self, object index) except NULL: + */ + PyThread_free_lock(__pyx_v_self->lock); + } + __pyx_L6_break:; + + /* "View.MemoryView":384 + * cdef int i + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: # <<<<<<<<<<<<<< + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: + */ + } + + /* "View.MemoryView":374 + * self.typeinfo = NULL + * + * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":395 + * PyThread_free_lock(self.lock) + * + * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf + */ + +static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { + Py_ssize_t __pyx_v_dim; + char *__pyx_v_itemp; + PyObject *__pyx_v_idx = NULL; + char *__pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *(*__pyx_t_4)(PyObject *); + PyObject *__pyx_t_5 = NULL; + Py_ssize_t __pyx_t_6; + char *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_item_pointer", 0); + + /* "View.MemoryView":397 + * cdef char *get_item_pointer(memoryview self, object index) except NULL: + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf # <<<<<<<<<<<<<< + * + * for dim, idx in enumerate(index): + */ + __pyx_v_itemp = ((char *)__pyx_v_self->view.buf); + + /* "View.MemoryView":399 + * cdef char *itemp = self.view.buf + * + * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * + */ + __pyx_t_1 = 0; + if (likely(PyList_CheckExact(__pyx_v_index)) || PyTuple_CheckExact(__pyx_v_index)) { + __pyx_t_2 = __pyx_v_index; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 399, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 399, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } else { + if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 399, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } + } else { + __pyx_t_5 = __pyx_t_4(__pyx_t_2); + if (unlikely(!__pyx_t_5)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 399, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_v_dim = __pyx_t_1; + __pyx_t_1 = (__pyx_t_1 + 1); + + /* "View.MemoryView":400 + * + * for dim, idx in enumerate(index): + * itemp = pybuffer_index(&self.view, itemp, idx, dim) # <<<<<<<<<<<<<< + * + * return itemp + */ + __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 400, __pyx_L1_error) + __pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(1, 400, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_7; + + /* "View.MemoryView":399 + * cdef char *itemp = self.view.buf + * + * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":402 + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * + * return itemp # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_itemp; + goto __pyx_L0; + + /* "View.MemoryView":395 + * PyThread_free_lock(self.lock) + * + * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.get_item_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_idx); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":405 + * + * + * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< + * if index is Ellipsis: + * return self + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index); /*proto*/ +static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { + PyObject *__pyx_v_have_slices = NULL; + PyObject *__pyx_v_indices = NULL; + char *__pyx_v_itemp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + char *__pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "View.MemoryView":406 + * + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self + * + */ + __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":407 + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: + * return self # <<<<<<<<<<<<<< + * + * have_slices, indices = _unellipsify(index, self.view.ndim) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "View.MemoryView":406 + * + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self + * + */ + } + + /* "View.MemoryView":409 + * return self + * + * have_slices, indices = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< + * + * cdef char *itemp + */ + __pyx_t_3 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (likely(__pyx_t_3 != Py_None)) { + PyObject* sequence = __pyx_t_3; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 409, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + #else + __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 409, __pyx_L1_error) + } + __pyx_v_have_slices = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_v_indices = __pyx_t_5; + __pyx_t_5 = 0; + + /* "View.MemoryView":412 + * + * cdef char *itemp + * if have_slices: # <<<<<<<<<<<<<< + * return memview_slice(self, indices) + * else: + */ + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 412, __pyx_L1_error) + if (__pyx_t_2) { + + /* "View.MemoryView":413 + * cdef char *itemp + * if have_slices: + * return memview_slice(self, indices) # <<<<<<<<<<<<<< + * else: + * itemp = self.get_item_pointer(indices) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":412 + * + * cdef char *itemp + * if have_slices: # <<<<<<<<<<<<<< + * return memview_slice(self, indices) + * else: + */ + } + + /* "View.MemoryView":415 + * return memview_slice(self, indices) + * else: + * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< + * return self.convert_item_to_object(itemp) + * + */ + /*else*/ { + __pyx_t_6 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_6 == ((char *)NULL))) __PYX_ERR(1, 415, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_6; + + /* "View.MemoryView":416 + * else: + * itemp = self.get_item_pointer(indices) + * return self.convert_item_to_object(itemp) # <<<<<<<<<<<<<< + * + * def __setitem__(memoryview self, object index, object value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":405 + * + * + * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< + * if index is Ellipsis: + * return self + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_have_slices); + __Pyx_XDECREF(__pyx_v_indices); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":418 + * return self.convert_item_to_object(itemp) + * + * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") + */ + +/* Python wrapper */ +static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + PyObject *__pyx_v_have_slices = NULL; + PyObject *__pyx_v_obj = NULL; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + __Pyx_INCREF(__pyx_v_index); + + /* "View.MemoryView":419 + * + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError("Cannot assign to read-only memoryview") + * + */ + __pyx_t_1 = (__pyx_v_self->view.readonly != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":420 + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< + * + * have_slices, index = _unellipsify(index, self.view.ndim) + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__13, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 420, __pyx_L1_error) + + /* "View.MemoryView":419 + * + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError("Cannot assign to read-only memoryview") + * + */ + } + + /* "View.MemoryView":422 + * raise TypeError("Cannot assign to read-only memoryview") + * + * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< + * + * if have_slices: + */ + __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(__pyx_t_2 != Py_None)) { + PyObject* sequence = __pyx_t_2; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 422, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 422, __pyx_L1_error) + } + __pyx_v_have_slices = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":424 + * have_slices, index = _unellipsify(index, self.view.ndim) + * + * if have_slices: # <<<<<<<<<<<<<< + * obj = self.is_slice(value) + * if obj: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 424, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":425 + * + * if have_slices: + * obj = self.is_slice(value) # <<<<<<<<<<<<<< + * if obj: + * self.setitem_slice_assignment(self[index], obj) + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_obj = __pyx_t_2; + __pyx_t_2 = 0; + + /* "View.MemoryView":426 + * if have_slices: + * obj = self.is_slice(value) + * if obj: # <<<<<<<<<<<<<< + * self.setitem_slice_assignment(self[index], obj) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 426, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":427 + * obj = self.is_slice(value) + * if obj: + * self.setitem_slice_assignment(self[index], obj) # <<<<<<<<<<<<<< + * else: + * self.setitem_slice_assign_scalar(self[index], value) + */ + __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_2, __pyx_v_obj); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":426 + * if have_slices: + * obj = self.is_slice(value) + * if obj: # <<<<<<<<<<<<<< + * self.setitem_slice_assignment(self[index], obj) + * else: + */ + goto __pyx_L5; + } + + /* "View.MemoryView":429 + * self.setitem_slice_assignment(self[index], obj) + * else: + * self.setitem_slice_assign_scalar(self[index], value) # <<<<<<<<<<<<<< + * else: + * self.setitem_indexed(index, value) + */ + /*else*/ { + __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_memoryview_type))))) __PYX_ERR(1, 429, __pyx_L1_error) + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_4), __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L5:; + + /* "View.MemoryView":424 + * have_slices, index = _unellipsify(index, self.view.ndim) + * + * if have_slices: # <<<<<<<<<<<<<< + * obj = self.is_slice(value) + * if obj: + */ + goto __pyx_L4; + } + + /* "View.MemoryView":431 + * self.setitem_slice_assign_scalar(self[index], value) + * else: + * self.setitem_indexed(index, value) # <<<<<<<<<<<<<< + * + * cdef is_slice(self, obj): + */ + /*else*/ { + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 431, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L4:; + + /* "View.MemoryView":418 + * return self.convert_item_to_object(itemp) + * + * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView.memoryview.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_have_slices); + __Pyx_XDECREF(__pyx_v_obj); + __Pyx_XDECREF(__pyx_v_index); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":433 + * self.setitem_indexed(index, value) + * + * cdef is_slice(self, obj): # <<<<<<<<<<<<<< + * if not isinstance(obj, memoryview): + * try: + */ + +static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_slice", 0); + __Pyx_INCREF(__pyx_v_obj); + + /* "View.MemoryView":434 + * + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + */ + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_obj, __pyx_memoryview_type); + __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":435 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + /*try:*/ { + + /* "View.MemoryView":436 + * if not isinstance(obj, memoryview): + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< + * self.dtype_is_object) + * except TypeError: + */ + __pyx_t_6 = __Pyx_PyInt_From_int(((__pyx_v_self->flags & (~PyBUF_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 436, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "View.MemoryView":437 + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) # <<<<<<<<<<<<<< + * except TypeError: + * return None + */ + __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 437, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_7); + + /* "View.MemoryView":436 + * if not isinstance(obj, memoryview): + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< + * self.dtype_is_object) + * except TypeError: + */ + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 436, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_v_obj); + __Pyx_GIVEREF(__pyx_v_obj); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_obj); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7); + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 436, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF_SET(__pyx_v_obj, __pyx_t_7); + __pyx_t_7 = 0; + + /* "View.MemoryView":435 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + */ + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L9_try_end; + __pyx_L4_error:; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "View.MemoryView":438 + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + * except TypeError: # <<<<<<<<<<<<<< + * return None + * + */ + __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); + if (__pyx_t_9) { + __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_6) < 0) __PYX_ERR(1, 438, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_t_6); + + /* "View.MemoryView":439 + * self.dtype_is_object) + * except TypeError: + * return None # <<<<<<<<<<<<<< + * + * return obj + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L7_except_return; + } + goto __pyx_L6_except_error; + __pyx_L6_except_error:; + + /* "View.MemoryView":435 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + */ + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + goto __pyx_L1_error; + __pyx_L7_except_return:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + goto __pyx_L0; + __pyx_L9_try_end:; + } + + /* "View.MemoryView":434 + * + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + */ + } + + /* "View.MemoryView":441 + * return None + * + * return obj # <<<<<<<<<<<<<< + * + * cdef setitem_slice_assignment(self, dst, src): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_obj); + __pyx_r = __pyx_v_obj; + goto __pyx_L0; + + /* "View.MemoryView":433 + * self.setitem_indexed(index, value) + * + * cdef is_slice(self, obj): # <<<<<<<<<<<<<< + * if not isinstance(obj, memoryview): + * try: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_obj); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":443 + * return obj + * + * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice dst_slice + * cdef __Pyx_memviewslice src_slice + */ + +static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src) { + __Pyx_memviewslice __pyx_v_dst_slice; + __Pyx_memviewslice __pyx_v_src_slice; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + __Pyx_memviewslice *__pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setitem_slice_assignment", 0); + + /* "View.MemoryView":447 + * cdef __Pyx_memviewslice src_slice + * + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<< + * get_slice_from_memview(dst, &dst_slice)[0], + * src.ndim, dst.ndim, self.dtype_is_object) + */ + if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_memoryview_type))))) __PYX_ERR(1, 447, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_src), (&__pyx_v_src_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 447, __pyx_L1_error) + + /* "View.MemoryView":448 + * + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], + * get_slice_from_memview(dst, &dst_slice)[0], # <<<<<<<<<<<<<< + * src.ndim, dst.ndim, self.dtype_is_object) + * + */ + if (!(likely(((__pyx_v_dst) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_dst, __pyx_memoryview_type))))) __PYX_ERR(1, 448, __pyx_L1_error) + __pyx_t_2 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_2 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 448, __pyx_L1_error) + + /* "View.MemoryView":449 + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], + * get_slice_from_memview(dst, &dst_slice)[0], + * src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<< + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 449, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 449, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":447 + * cdef __Pyx_memviewslice src_slice + * + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<< + * get_slice_from_memview(dst, &dst_slice)[0], + * src.ndim, dst.ndim, self.dtype_is_object) + */ + __pyx_t_6 = __pyx_memoryview_copy_contents((__pyx_t_1[0]), (__pyx_t_2[0]), __pyx_t_4, __pyx_t_5, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 447, __pyx_L1_error) + + /* "View.MemoryView":443 + * return obj + * + * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice dst_slice + * cdef __Pyx_memviewslice src_slice + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assignment", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":451 + * src.ndim, dst.ndim, self.dtype_is_object) + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< + * cdef int array[128] + * cdef void *tmp = NULL + */ + +static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value) { + int __pyx_v_array[0x80]; + void *__pyx_v_tmp; + void *__pyx_v_item; + __Pyx_memviewslice *__pyx_v_dst_slice; + __Pyx_memviewslice __pyx_v_tmp_slice; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + char const *__pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 0); + + /* "View.MemoryView":453 + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): + * cdef int array[128] + * cdef void *tmp = NULL # <<<<<<<<<<<<<< + * cdef void *item + * + */ + __pyx_v_tmp = NULL; + + /* "View.MemoryView":458 + * cdef __Pyx_memviewslice *dst_slice + * cdef __Pyx_memviewslice tmp_slice + * dst_slice = get_slice_from_memview(dst, &tmp_slice) # <<<<<<<<<<<<<< + * + * if self.view.itemsize > sizeof(array): + */ + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 458, __pyx_L1_error) + __pyx_v_dst_slice = __pyx_t_1; + + /* "View.MemoryView":460 + * dst_slice = get_slice_from_memview(dst, &tmp_slice) + * + * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: + */ + __pyx_t_2 = ((((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array))) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":461 + * + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) # <<<<<<<<<<<<<< + * if tmp == NULL: + * raise MemoryError + */ + __pyx_v_tmp = PyMem_Malloc(__pyx_v_self->view.itemsize); + + /* "View.MemoryView":462 + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * item = tmp + */ + __pyx_t_2 = ((__pyx_v_tmp == NULL) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":463 + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * item = tmp + * else: + */ + PyErr_NoMemory(); __PYX_ERR(1, 463, __pyx_L1_error) + + /* "View.MemoryView":462 + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * item = tmp + */ + } + + /* "View.MemoryView":464 + * if tmp == NULL: + * raise MemoryError + * item = tmp # <<<<<<<<<<<<<< + * else: + * item = array + */ + __pyx_v_item = __pyx_v_tmp; + + /* "View.MemoryView":460 + * dst_slice = get_slice_from_memview(dst, &tmp_slice) + * + * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":466 + * item = tmp + * else: + * item = array # <<<<<<<<<<<<<< + * + * try: + */ + /*else*/ { + __pyx_v_item = ((void *)__pyx_v_array); + } + __pyx_L3:; + + /* "View.MemoryView":468 + * item = array + * + * try: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * ( item)[0] = value + */ + /*try:*/ { + + /* "View.MemoryView":469 + * + * try: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * ( item)[0] = value + * else: + */ + __pyx_t_2 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":470 + * try: + * if self.dtype_is_object: + * ( item)[0] = value # <<<<<<<<<<<<<< + * else: + * self.assign_item_from_object( item, value) + */ + (((PyObject **)__pyx_v_item)[0]) = ((PyObject *)__pyx_v_value); + + /* "View.MemoryView":469 + * + * try: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * ( item)[0] = value + * else: + */ + goto __pyx_L8; + } + + /* "View.MemoryView":472 + * ( item)[0] = value + * else: + * self.assign_item_from_object( item, value) # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, ((char *)__pyx_v_item), __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 472, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L8:; + + /* "View.MemoryView":476 + * + * + * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, + */ + __pyx_t_2 = ((__pyx_v_self->view.suboffsets != NULL) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":477 + * + * if self.view.suboffsets != NULL: + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) # <<<<<<<<<<<<<< + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, + * item, self.dtype_is_object) + */ + __pyx_t_3 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 477, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":476 + * + * + * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, + */ + } + + /* "View.MemoryView":478 + * if self.view.suboffsets != NULL: + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, # <<<<<<<<<<<<<< + * item, self.dtype_is_object) + * finally: + */ + __pyx_memoryview_slice_assign_scalar(__pyx_v_dst_slice, __pyx_v_dst->view.ndim, __pyx_v_self->view.itemsize, __pyx_v_item, __pyx_v_self->dtype_is_object); + } + + /* "View.MemoryView":481 + * item, self.dtype_is_object) + * finally: + * PyMem_Free(tmp) # <<<<<<<<<<<<<< + * + * cdef setitem_indexed(self, index, value): + */ + /*finally:*/ { + /*normal exit:*/{ + PyMem_Free(__pyx_v_tmp); + goto __pyx_L7; + } + __pyx_L6_error:; + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename; + { + PyMem_Free(__pyx_v_tmp); + } + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + } + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ErrRestore(__pyx_t_7, __pyx_t_8, __pyx_t_9); + __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; + __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_6; + goto __pyx_L1_error; + } + __pyx_L7:; + } + + /* "View.MemoryView":451 + * src.ndim, dst.ndim, self.dtype_is_object) + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< + * cdef int array[128] + * cdef void *tmp = NULL + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":483 + * PyMem_Free(tmp) + * + * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< + * cdef char *itemp = self.get_item_pointer(index) + * self.assign_item_from_object(itemp, value) + */ + +static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + char *__pyx_v_itemp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setitem_indexed", 0); + + /* "View.MemoryView":484 + * + * cdef setitem_indexed(self, index, value): + * cdef char *itemp = self.get_item_pointer(index) # <<<<<<<<<<<<<< + * self.assign_item_from_object(itemp, value) + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_index); if (unlikely(__pyx_t_1 == ((char *)NULL))) __PYX_ERR(1, 484, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_1; + + /* "View.MemoryView":485 + * cdef setitem_indexed(self, index, value): + * cdef char *itemp = self.get_item_pointer(index) + * self.assign_item_from_object(itemp, value) # <<<<<<<<<<<<<< + * + * cdef convert_item_to_object(self, char *itemp): + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 485, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":483 + * PyMem_Free(tmp) + * + * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< + * cdef char *itemp = self.get_item_pointer(index) + * self.assign_item_from_object(itemp, value) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_indexed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":487 + * self.assign_item_from_object(itemp, value) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + */ + +static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp) { + PyObject *__pyx_v_struct = NULL; + PyObject *__pyx_v_bytesitem = 0; + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; + int __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("convert_item_to_object", 0); + + /* "View.MemoryView":490 + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + * import struct # <<<<<<<<<<<<<< + * cdef bytes bytesitem + * + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_struct = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":493 + * cdef bytes bytesitem + * + * bytesitem = itemp[:self.view.itemsize] # <<<<<<<<<<<<<< + * try: + * result = struct.unpack(self.view.format, bytesitem) + */ + __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_itemp + 0, __pyx_v_self->view.itemsize - 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_bytesitem = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":494 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + /*try:*/ { + + /* "View.MemoryView":495 + * bytesitem = itemp[:self.view.itemsize] + * try: + * result = struct.unpack(self.view.format, bytesitem) # <<<<<<<<<<<<<< + * except struct.error: + * raise ValueError("Unable to convert item to object") + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_unpack); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6); + __Pyx_INCREF(__pyx_v_bytesitem); + __Pyx_GIVEREF(__pyx_v_bytesitem); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_bytesitem); + __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":494 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + */ + } + + /* "View.MemoryView":499 + * raise ValueError("Unable to convert item to object") + * else: + * if len(self.view.format) == 1: # <<<<<<<<<<<<<< + * return result[0] + * return result + */ + /*else:*/ { + __pyx_t_10 = strlen(__pyx_v_self->view.format); + __pyx_t_11 = ((__pyx_t_10 == 1) != 0); + if (__pyx_t_11) { + + /* "View.MemoryView":500 + * else: + * if len(self.view.format) == 1: + * return result[0] # <<<<<<<<<<<<<< + * return result + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_result, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 500, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L6_except_return; + + /* "View.MemoryView":499 + * raise ValueError("Unable to convert item to object") + * else: + * if len(self.view.format) == 1: # <<<<<<<<<<<<<< + * return result[0] + * return result + */ + } + + /* "View.MemoryView":501 + * if len(self.view.format) == 1: + * return result[0] + * return result # <<<<<<<<<<<<<< + * + * cdef assign_item_from_object(self, char *itemp, object value): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L6_except_return; + } + __pyx_L3_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "View.MemoryView":496 + * try: + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: # <<<<<<<<<<<<<< + * raise ValueError("Unable to convert item to object") + * else: + */ + __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_5, &__pyx_t_9); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 496, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_9); + __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_9 = 0; + if (__pyx_t_8) { + __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 496, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_1); + + /* "View.MemoryView":497 + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< + * else: + * if len(self.view.format) == 1: + */ + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__14, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 497, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(1, 497, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "View.MemoryView":494 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + */ + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L1_error; + __pyx_L6_except_return:; + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L0; + } + + /* "View.MemoryView":487 + * self.assign_item_from_object(itemp, value) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_struct); + __Pyx_XDECREF(__pyx_v_bytesitem); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":503 + * return result + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + */ + +static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { + PyObject *__pyx_v_struct = NULL; + char __pyx_v_c; + PyObject *__pyx_v_bytesvalue = 0; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + Py_ssize_t __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + char *__pyx_t_11; + char *__pyx_t_12; + char *__pyx_t_13; + char *__pyx_t_14; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("assign_item_from_object", 0); + + /* "View.MemoryView":506 + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + * import struct # <<<<<<<<<<<<<< + * cdef char c + * cdef bytes bytesvalue + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 506, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_struct = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":511 + * cdef Py_ssize_t i + * + * if isinstance(value, tuple): # <<<<<<<<<<<<<< + * bytesvalue = struct.pack(self.view.format, *value) + * else: + */ + __pyx_t_2 = PyTuple_Check(__pyx_v_value); + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "View.MemoryView":512 + * + * if isinstance(value, tuple): + * bytesvalue = struct.pack(self.view.format, *value) # <<<<<<<<<<<<<< + * else: + * bytesvalue = struct.pack(self.view.format, value) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||((void)PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 512, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":511 + * cdef Py_ssize_t i + * + * if isinstance(value, tuple): # <<<<<<<<<<<<<< + * bytesvalue = struct.pack(self.view.format, *value) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":514 + * bytesvalue = struct.pack(self.view.format, *value) + * else: + * bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<< + * + * for i, c in enumerate(bytesvalue): + */ + /*else*/ { + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_value); + __pyx_t_1 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||((void)PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 514, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + } + __pyx_L3:; + + /* "View.MemoryView":516 + * bytesvalue = struct.pack(self.view.format, value) + * + * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< + * itemp[i] = c + * + */ + __pyx_t_9 = 0; + if (unlikely(__pyx_v_bytesvalue == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable"); + __PYX_ERR(1, 516, __pyx_L1_error) + } + __Pyx_INCREF(__pyx_v_bytesvalue); + __pyx_t_10 = __pyx_v_bytesvalue; + __pyx_t_12 = PyBytes_AS_STRING(__pyx_t_10); + __pyx_t_13 = (__pyx_t_12 + PyBytes_GET_SIZE(__pyx_t_10)); + for (__pyx_t_14 = __pyx_t_12; __pyx_t_14 < __pyx_t_13; __pyx_t_14++) { + __pyx_t_11 = __pyx_t_14; + __pyx_v_c = (__pyx_t_11[0]); + + /* "View.MemoryView":517 + * + * for i, c in enumerate(bytesvalue): + * itemp[i] = c # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + __pyx_v_i = __pyx_t_9; + + /* "View.MemoryView":516 + * bytesvalue = struct.pack(self.view.format, value) + * + * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< + * itemp[i] = c + * + */ + __pyx_t_9 = (__pyx_t_9 + 1); + + /* "View.MemoryView":517 + * + * for i, c in enumerate(bytesvalue): + * itemp[i] = c # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c; + } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "View.MemoryView":503 + * return result + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("View.MemoryView.memoryview.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_struct); + __Pyx_XDECREF(__pyx_v_bytesvalue); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":520 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError("Cannot create writable memory view from read-only memoryview") + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t *__pyx_t_4; + char *__pyx_t_5; + void *__pyx_t_6; + int __pyx_t_7; + Py_ssize_t __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + if (__pyx_v_info == NULL) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + + /* "View.MemoryView":521 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + */ + __pyx_t_2 = ((__pyx_v_flags & PyBUF_WRITABLE) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_self->view.readonly != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":522 + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<< + * + * if flags & PyBUF_ND: + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__15, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 522, __pyx_L1_error) + + /* "View.MemoryView":521 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + */ + } + + /* "View.MemoryView":524 + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + * if flags & PyBUF_ND: # <<<<<<<<<<<<<< + * info.shape = self.view.shape + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":525 + * + * if flags & PyBUF_ND: + * info.shape = self.view.shape # <<<<<<<<<<<<<< + * else: + * info.shape = NULL + */ + __pyx_t_4 = __pyx_v_self->view.shape; + __pyx_v_info->shape = __pyx_t_4; + + /* "View.MemoryView":524 + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + * if flags & PyBUF_ND: # <<<<<<<<<<<<<< + * info.shape = self.view.shape + * else: + */ + goto __pyx_L6; + } + + /* "View.MemoryView":527 + * info.shape = self.view.shape + * else: + * info.shape = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_STRIDES: + */ + /*else*/ { + __pyx_v_info->shape = NULL; + } + __pyx_L6:; + + /* "View.MemoryView":529 + * info.shape = NULL + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.strides = self.view.strides + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":530 + * + * if flags & PyBUF_STRIDES: + * info.strides = self.view.strides # <<<<<<<<<<<<<< + * else: + * info.strides = NULL + */ + __pyx_t_4 = __pyx_v_self->view.strides; + __pyx_v_info->strides = __pyx_t_4; + + /* "View.MemoryView":529 + * info.shape = NULL + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.strides = self.view.strides + * else: + */ + goto __pyx_L7; + } + + /* "View.MemoryView":532 + * info.strides = self.view.strides + * else: + * info.strides = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_INDIRECT: + */ + /*else*/ { + __pyx_v_info->strides = NULL; + } + __pyx_L7:; + + /* "View.MemoryView":534 + * info.strides = NULL + * + * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< + * info.suboffsets = self.view.suboffsets + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_INDIRECT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":535 + * + * if flags & PyBUF_INDIRECT: + * info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<< + * else: + * info.suboffsets = NULL + */ + __pyx_t_4 = __pyx_v_self->view.suboffsets; + __pyx_v_info->suboffsets = __pyx_t_4; + + /* "View.MemoryView":534 + * info.strides = NULL + * + * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< + * info.suboffsets = self.view.suboffsets + * else: + */ + goto __pyx_L8; + } + + /* "View.MemoryView":537 + * info.suboffsets = self.view.suboffsets + * else: + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + /*else*/ { + __pyx_v_info->suboffsets = NULL; + } + __pyx_L8:; + + /* "View.MemoryView":539 + * info.suboffsets = NULL + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.view.format + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":540 + * + * if flags & PyBUF_FORMAT: + * info.format = self.view.format # <<<<<<<<<<<<<< + * else: + * info.format = NULL + */ + __pyx_t_5 = __pyx_v_self->view.format; + __pyx_v_info->format = __pyx_t_5; + + /* "View.MemoryView":539 + * info.suboffsets = NULL + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.view.format + * else: + */ + goto __pyx_L9; + } + + /* "View.MemoryView":542 + * info.format = self.view.format + * else: + * info.format = NULL # <<<<<<<<<<<<<< + * + * info.buf = self.view.buf + */ + /*else*/ { + __pyx_v_info->format = NULL; + } + __pyx_L9:; + + /* "View.MemoryView":544 + * info.format = NULL + * + * info.buf = self.view.buf # <<<<<<<<<<<<<< + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize + */ + __pyx_t_6 = __pyx_v_self->view.buf; + __pyx_v_info->buf = __pyx_t_6; + + /* "View.MemoryView":545 + * + * info.buf = self.view.buf + * info.ndim = self.view.ndim # <<<<<<<<<<<<<< + * info.itemsize = self.view.itemsize + * info.len = self.view.len + */ + __pyx_t_7 = __pyx_v_self->view.ndim; + __pyx_v_info->ndim = __pyx_t_7; + + /* "View.MemoryView":546 + * info.buf = self.view.buf + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize # <<<<<<<<<<<<<< + * info.len = self.view.len + * info.readonly = self.view.readonly + */ + __pyx_t_8 = __pyx_v_self->view.itemsize; + __pyx_v_info->itemsize = __pyx_t_8; + + /* "View.MemoryView":547 + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize + * info.len = self.view.len # <<<<<<<<<<<<<< + * info.readonly = self.view.readonly + * info.obj = self + */ + __pyx_t_8 = __pyx_v_self->view.len; + __pyx_v_info->len = __pyx_t_8; + + /* "View.MemoryView":548 + * info.itemsize = self.view.itemsize + * info.len = self.view.len + * info.readonly = self.view.readonly # <<<<<<<<<<<<<< + * info.obj = self + * + */ + __pyx_t_1 = __pyx_v_self->view.readonly; + __pyx_v_info->readonly = __pyx_t_1; + + /* "View.MemoryView":549 + * info.len = self.view.len + * info.readonly = self.view.readonly + * info.obj = self # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") + */ + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + + /* "View.MemoryView":520 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError("Cannot create writable memory view from read-only memoryview") + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":555 + * + * @property + * def T(self): # <<<<<<<<<<<<<< + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":556 + * @property + * def T(self): + * cdef _memoryviewslice result = memoryview_copy(self) # <<<<<<<<<<<<<< + * transpose_memslice(&result.from_slice) + * return result + */ + __pyx_t_1 = __pyx_memoryview_copy_object(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 556, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_memoryviewslice_type))))) __PYX_ERR(1, 556, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":557 + * def T(self): + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_2 = __pyx_memslice_transpose((&__pyx_v_result->from_slice)); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 557, __pyx_L1_error) + + /* "View.MemoryView":558 + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) + * return result # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "View.MemoryView":555 + * + * @property + * def T(self): # <<<<<<<<<<<<<< + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.T.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":561 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.obj + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":562 + * @property + * def base(self): + * return self.obj # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->obj); + __pyx_r = __pyx_v_self->obj; + goto __pyx_L0; + + /* "View.MemoryView":561 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.obj + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":565 + * + * @property + * def shape(self): # <<<<<<<<<<<<<< + * return tuple([length for length in self.view.shape[:self.view.ndim]]) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_v_length; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":566 + * @property + * def shape(self): + * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); + for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { + __pyx_t_2 = __pyx_t_4; + __pyx_v_length = (__pyx_t_2[0]); + __pyx_t_5 = PyInt_FromSsize_t(__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "View.MemoryView":565 + * + * @property + * def shape(self): # <<<<<<<<<<<<<< + * return tuple([length for length in self.view.shape[:self.view.ndim]]) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.shape.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":569 + * + * @property + * def strides(self): # <<<<<<<<<<<<<< + * if self.view.strides == NULL: + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_v_stride; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":570 + * @property + * def strides(self): + * if self.view.strides == NULL: # <<<<<<<<<<<<<< + * + * raise ValueError("Buffer view does not expose strides") + */ + __pyx_t_1 = ((__pyx_v_self->view.strides == NULL) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":572 + * if self.view.strides == NULL: + * + * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 572, __pyx_L1_error) + + /* "View.MemoryView":570 + * @property + * def strides(self): + * if self.view.strides == NULL: # <<<<<<<<<<<<<< + * + * raise ValueError("Buffer view does not expose strides") + */ + } + + /* "View.MemoryView":574 + * raise ValueError("Buffer view does not expose strides") + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = (__pyx_v_self->view.strides + __pyx_v_self->view.ndim); + for (__pyx_t_5 = __pyx_v_self->view.strides; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { + __pyx_t_3 = __pyx_t_5; + __pyx_v_stride = (__pyx_t_3[0]); + __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; + goto __pyx_L0; + + /* "View.MemoryView":569 + * + * @property + * def strides(self): # <<<<<<<<<<<<<< + * if self.view.strides == NULL: + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView.memoryview.strides.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":577 + * + * @property + * def suboffsets(self): # <<<<<<<<<<<<<< + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_v_suboffset; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + Py_ssize_t *__pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":578 + * @property + * def suboffsets(self): + * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< + * return (-1,) * self.view.ndim + * + */ + __pyx_t_1 = ((__pyx_v_self->view.suboffsets == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":579 + * def suboffsets(self): + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_tuple__17, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":578 + * @property + * def suboffsets(self): + * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< + * return (-1,) * self.view.ndim + * + */ + } + + /* "View.MemoryView":581 + * return (-1,) * self.view.ndim + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim); + for (__pyx_t_6 = __pyx_v_self->view.suboffsets; __pyx_t_6 < __pyx_t_5; __pyx_t_6++) { + __pyx_t_4 = __pyx_t_6; + __pyx_v_suboffset = (__pyx_t_4[0]); + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_suboffset); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_2))) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = PyList_AsTuple(((PyObject*)__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":577 + * + * @property + * def suboffsets(self): # <<<<<<<<<<<<<< + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.suboffsets.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":584 + * + * @property + * def ndim(self): # <<<<<<<<<<<<<< + * return self.view.ndim + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":585 + * @property + * def ndim(self): + * return self.view.ndim # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 585, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":584 + * + * @property + * def ndim(self): # <<<<<<<<<<<<<< + * return self.view.ndim + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.ndim.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":588 + * + * @property + * def itemsize(self): # <<<<<<<<<<<<<< + * return self.view.itemsize + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":589 + * @property + * def itemsize(self): + * return self.view.itemsize # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":588 + * + * @property + * def itemsize(self): # <<<<<<<<<<<<<< + * return self.view.itemsize + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.itemsize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":592 + * + * @property + * def nbytes(self): # <<<<<<<<<<<<<< + * return self.size * self.view.itemsize + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":593 + * @property + * def nbytes(self): + * return self.size * self.view.itemsize # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":592 + * + * @property + * def nbytes(self): # <<<<<<<<<<<<<< + * return self.size * self.view.itemsize + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.nbytes.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":596 + * + * @property + * def size(self): # <<<<<<<<<<<<<< + * if self._size is None: + * result = 1 + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_v_length = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":597 + * @property + * def size(self): + * if self._size is None: # <<<<<<<<<<<<<< + * result = 1 + * + */ + __pyx_t_1 = (__pyx_v_self->_size == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":598 + * def size(self): + * if self._size is None: + * result = 1 # <<<<<<<<<<<<<< + * + * for length in self.view.shape[:self.view.ndim]: + */ + __Pyx_INCREF(__pyx_int_1); + __pyx_v_result = __pyx_int_1; + + /* "View.MemoryView":600 + * result = 1 + * + * for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<< + * result *= length + * + */ + __pyx_t_4 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); + for (__pyx_t_5 = __pyx_v_self->view.shape; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { + __pyx_t_3 = __pyx_t_5; + __pyx_t_6 = PyInt_FromSsize_t((__pyx_t_3[0])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_6); + __pyx_t_6 = 0; + + /* "View.MemoryView":601 + * + * for length in self.view.shape[:self.view.ndim]: + * result *= length # <<<<<<<<<<<<<< + * + * self._size = result + */ + __pyx_t_6 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_6); + __pyx_t_6 = 0; + } + + /* "View.MemoryView":603 + * result *= length + * + * self._size = result # <<<<<<<<<<<<<< + * + * return self._size + */ + __Pyx_INCREF(__pyx_v_result); + __Pyx_GIVEREF(__pyx_v_result); + __Pyx_GOTREF(__pyx_v_self->_size); + __Pyx_DECREF(__pyx_v_self->_size); + __pyx_v_self->_size = __pyx_v_result; + + /* "View.MemoryView":597 + * @property + * def size(self): + * if self._size is None: # <<<<<<<<<<<<<< + * result = 1 + * + */ + } + + /* "View.MemoryView":605 + * self._size = result + * + * return self._size # <<<<<<<<<<<<<< + * + * def __len__(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_size); + __pyx_r = __pyx_v_self->_size; + goto __pyx_L0; + + /* "View.MemoryView":596 + * + * @property + * def size(self): # <<<<<<<<<<<<<< + * if self._size is None: + * result = 1 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView.memoryview.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_length); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":607 + * return self._size + * + * def __len__(self): # <<<<<<<<<<<<<< + * if self.view.ndim >= 1: + * return self.view.shape[0] + */ + +/* Python wrapper */ +static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self); /*proto*/ +static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__len__", 0); + + /* "View.MemoryView":608 + * + * def __len__(self): + * if self.view.ndim >= 1: # <<<<<<<<<<<<<< + * return self.view.shape[0] + * + */ + __pyx_t_1 = ((__pyx_v_self->view.ndim >= 1) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":609 + * def __len__(self): + * if self.view.ndim >= 1: + * return self.view.shape[0] # <<<<<<<<<<<<<< + * + * return 0 + */ + __pyx_r = (__pyx_v_self->view.shape[0]); + goto __pyx_L0; + + /* "View.MemoryView":608 + * + * def __len__(self): + * if self.view.ndim >= 1: # <<<<<<<<<<<<<< + * return self.view.shape[0] + * + */ + } + + /* "View.MemoryView":611 + * return self.view.shape[0] + * + * return 0 # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":607 + * return self._size + * + * def __len__(self): # <<<<<<<<<<<<<< + * if self.view.ndim >= 1: + * return self.view.shape[0] + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":613 + * return 0 + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__, + * id(self)) + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "View.MemoryView":614 + * + * def __repr__(self): + * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< + * id(self)) + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":615 + * def __repr__(self): + * return "" % (self.base.__class__.__name__, + * id(self)) # <<<<<<<<<<<<<< + * + * def __str__(self): + */ + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "View.MemoryView":614 + * + * def __repr__(self): + * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< + * id(self)) + * + */ + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":613 + * return 0 + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__, + * id(self)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":617 + * id(self)) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__,) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__str__", 0); + + /* "View.MemoryView":618 + * + * def __str__(self): + * return "" % (self.base.__class__.__name__,) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_object, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":617 + * id(self)) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__,) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":621 + * + * + * def is_c_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_c_contig (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice *__pyx_v_mslice; + __Pyx_memviewslice __pyx_v_tmp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_c_contig", 0); + + /* "View.MemoryView":624 + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< + * return slice_is_contig(mslice[0], 'C', self.view.ndim) + * + */ + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 624, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":625 + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) + * return slice_is_contig(mslice[0], 'C', self.view.ndim) # <<<<<<<<<<<<<< + * + * def is_f_contig(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'C', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":621 + * + * + * def is_c_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.is_c_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":627 + * return slice_is_contig(mslice[0], 'C', self.view.ndim) + * + * def is_f_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_f_contig (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice *__pyx_v_mslice; + __Pyx_memviewslice __pyx_v_tmp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_f_contig", 0); + + /* "View.MemoryView":630 + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< + * return slice_is_contig(mslice[0], 'F', self.view.ndim) + * + */ + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 630, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":631 + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) + * return slice_is_contig(mslice[0], 'F', self.view.ndim) # <<<<<<<<<<<<<< + * + * def copy(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'F', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":627 + * return slice_is_contig(mslice[0], 'C', self.view.ndim) + * + * def is_f_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.is_f_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":633 + * return slice_is_contig(mslice[0], 'F', self.view.ndim) + * + * def copy(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice mslice + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice __pyx_v_mslice; + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("copy", 0); + + /* "View.MemoryView":635 + * def copy(self): + * cdef __Pyx_memviewslice mslice + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS # <<<<<<<<<<<<<< + * + * slice_copy(self, &mslice) + */ + __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_F_CONTIGUOUS)); + + /* "View.MemoryView":637 + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS + * + * slice_copy(self, &mslice) # <<<<<<<<<<<<<< + * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, + * self.view.itemsize, + */ + __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_mslice)); + + /* "View.MemoryView":638 + * + * slice_copy(self, &mslice) + * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, # <<<<<<<<<<<<<< + * self.view.itemsize, + * flags|PyBUF_C_CONTIGUOUS, + */ + __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_mslice), ((char *)"c"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_C_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 638, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":643 + * self.dtype_is_object) + * + * return memoryview_copy_from_slice(self, &mslice) # <<<<<<<<<<<<<< + * + * def copy_fortran(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_mslice)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 643, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":633 + * return slice_is_contig(mslice[0], 'F', self.view.ndim) + * + * def copy(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice mslice + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":645 + * return memoryview_copy_from_slice(self, &mslice) + * + * def copy_fortran(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice src, dst + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy_fortran (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice __pyx_v_src; + __Pyx_memviewslice __pyx_v_dst; + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("copy_fortran", 0); + + /* "View.MemoryView":647 + * def copy_fortran(self): + * cdef __Pyx_memviewslice src, dst + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS # <<<<<<<<<<<<<< + * + * slice_copy(self, &src) + */ + __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_C_CONTIGUOUS)); + + /* "View.MemoryView":649 + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS + * + * slice_copy(self, &src) # <<<<<<<<<<<<<< + * dst = slice_copy_contig(&src, "fortran", self.view.ndim, + * self.view.itemsize, + */ + __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_src)); + + /* "View.MemoryView":650 + * + * slice_copy(self, &src) + * dst = slice_copy_contig(&src, "fortran", self.view.ndim, # <<<<<<<<<<<<<< + * self.view.itemsize, + * flags|PyBUF_F_CONTIGUOUS, + */ + __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_src), ((char *)"fortran"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_F_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 650, __pyx_L1_error) + __pyx_v_dst = __pyx_t_1; + + /* "View.MemoryView":655 + * self.dtype_is_object) + * + * return memoryview_copy_from_slice(self, &dst) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_dst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 655, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":645 + * return memoryview_copy_from_slice(self, &mslice) + * + * def copy_fortran(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice src, dst + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.copy_fortran", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_memoryview___reduce_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__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.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__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.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":659 + * + * @cname('__pyx_memoryview_new') + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo + */ + +static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, int __pyx_v_dtype_is_object, __Pyx_TypeInfo *__pyx_v_typeinfo) { + struct __pyx_memoryview_obj *__pyx_v_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_cwrapper", 0); + + /* "View.MemoryView":660 + * @cname('__pyx_memoryview_new') + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): + * cdef memoryview result = memoryview(o, flags, dtype_is_object) # <<<<<<<<<<<<<< + * result.typeinfo = typeinfo + * return result + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_o); + __Pyx_GIVEREF(__pyx_v_o); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_o); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = ((struct __pyx_memoryview_obj *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":661 + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_v_result->typeinfo = __pyx_v_typeinfo; + + /* "View.MemoryView":662 + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo + * return result # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_check') + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "View.MemoryView":659 + * + * @cname('__pyx_memoryview_new') + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":665 + * + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< + * return isinstance(o, memoryview) + * + */ + +static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("memoryview_check", 0); + + /* "View.MemoryView":666 + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): + * return isinstance(o, memoryview) # <<<<<<<<<<<<<< + * + * cdef tuple _unellipsify(object index, int ndim): + */ + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_o, __pyx_memoryview_type); + __pyx_r = __pyx_t_1; + goto __pyx_L0; + + /* "View.MemoryView":665 + * + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< + * return isinstance(o, memoryview) + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":668 + * return isinstance(o, memoryview) + * + * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< + * """ + * Replace all ellipses with full slices and fill incomplete indices with + */ + +static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { + PyObject *__pyx_v_tup = NULL; + PyObject *__pyx_v_result = NULL; + int __pyx_v_have_slices; + int __pyx_v_seen_ellipsis; + CYTHON_UNUSED PyObject *__pyx_v_idx = NULL; + PyObject *__pyx_v_item = NULL; + Py_ssize_t __pyx_v_nslices; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + PyObject *__pyx_t_7 = NULL; + Py_ssize_t __pyx_t_8; + int __pyx_t_9; + int __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_unellipsify", 0); + + /* "View.MemoryView":673 + * full slices. + * """ + * if not isinstance(index, tuple): # <<<<<<<<<<<<<< + * tup = (index,) + * else: + */ + __pyx_t_1 = PyTuple_Check(__pyx_v_index); + __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":674 + * """ + * if not isinstance(index, tuple): + * tup = (index,) # <<<<<<<<<<<<<< + * else: + * tup = index + */ + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 674, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_index); + __Pyx_GIVEREF(__pyx_v_index); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_index); + __pyx_v_tup = __pyx_t_3; + __pyx_t_3 = 0; + + /* "View.MemoryView":673 + * full slices. + * """ + * if not isinstance(index, tuple): # <<<<<<<<<<<<<< + * tup = (index,) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":676 + * tup = (index,) + * else: + * tup = index # <<<<<<<<<<<<<< + * + * result = [] + */ + /*else*/ { + __Pyx_INCREF(__pyx_v_index); + __pyx_v_tup = __pyx_v_index; + } + __pyx_L3:; + + /* "View.MemoryView":678 + * tup = index + * + * result = [] # <<<<<<<<<<<<<< + * have_slices = False + * seen_ellipsis = False + */ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 678, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_result = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":679 + * + * result = [] + * have_slices = False # <<<<<<<<<<<<<< + * seen_ellipsis = False + * for idx, item in enumerate(tup): + */ + __pyx_v_have_slices = 0; + + /* "View.MemoryView":680 + * result = [] + * have_slices = False + * seen_ellipsis = False # <<<<<<<<<<<<<< + * for idx, item in enumerate(tup): + * if item is Ellipsis: + */ + __pyx_v_seen_ellipsis = 0; + + /* "View.MemoryView":681 + * have_slices = False + * seen_ellipsis = False + * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< + * if item is Ellipsis: + * if not seen_ellipsis: + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_3 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_tup)) || PyTuple_CheckExact(__pyx_v_tup)) { + __pyx_t_4 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_tup); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 681, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_4))) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 681, __pyx_L1_error) + #else + __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } else { + if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 681, __pyx_L1_error) + #else + __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } + } else { + __pyx_t_7 = __pyx_t_6(__pyx_t_4); + if (unlikely(!__pyx_t_7)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 681, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_7); + } + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_3); + __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); + __pyx_t_3 = __pyx_t_7; + __pyx_t_7 = 0; + + /* "View.MemoryView":682 + * seen_ellipsis = False + * for idx, item in enumerate(tup): + * if item is Ellipsis: # <<<<<<<<<<<<<< + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + */ + __pyx_t_2 = (__pyx_v_item == __pyx_builtin_Ellipsis); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":683 + * for idx, item in enumerate(tup): + * if item is Ellipsis: + * if not seen_ellipsis: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True + */ + __pyx_t_1 = ((!(__pyx_v_seen_ellipsis != 0)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":684 + * if item is Ellipsis: + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<< + * seen_ellipsis = True + * else: + */ + __pyx_t_8 = PyObject_Length(__pyx_v_tup); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(1, 684, __pyx_L1_error) + __pyx_t_7 = PyList_New(1 * ((((__pyx_v_ndim - __pyx_t_8) + 1)<0) ? 0:((__pyx_v_ndim - __pyx_t_8) + 1))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 684, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < ((__pyx_v_ndim - __pyx_t_8) + 1); __pyx_temp++) { + __Pyx_INCREF(__pyx_slice__20); + __Pyx_GIVEREF(__pyx_slice__20); + PyList_SET_ITEM(__pyx_t_7, __pyx_temp, __pyx_slice__20); + } + } + __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_7); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 684, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "View.MemoryView":685 + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True # <<<<<<<<<<<<<< + * else: + * result.append(slice(None)) + */ + __pyx_v_seen_ellipsis = 1; + + /* "View.MemoryView":683 + * for idx, item in enumerate(tup): + * if item is Ellipsis: + * if not seen_ellipsis: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True + */ + goto __pyx_L7; + } + + /* "View.MemoryView":687 + * seen_ellipsis = True + * else: + * result.append(slice(None)) # <<<<<<<<<<<<<< + * have_slices = True + * else: + */ + /*else*/ { + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_slice__20); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 687, __pyx_L1_error) + } + __pyx_L7:; + + /* "View.MemoryView":688 + * else: + * result.append(slice(None)) + * have_slices = True # <<<<<<<<<<<<<< + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): + */ + __pyx_v_have_slices = 1; + + /* "View.MemoryView":682 + * seen_ellipsis = False + * for idx, item in enumerate(tup): + * if item is Ellipsis: # <<<<<<<<<<<<<< + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + */ + goto __pyx_L6; + } + + /* "View.MemoryView":690 + * have_slices = True + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + */ + /*else*/ { + __pyx_t_2 = PySlice_Check(__pyx_v_item); + __pyx_t_10 = ((!(__pyx_t_2 != 0)) != 0); + if (__pyx_t_10) { + } else { + __pyx_t_1 = __pyx_t_10; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_10 = ((!(PyIndex_Check(__pyx_v_item) != 0)) != 0); + __pyx_t_1 = __pyx_t_10; + __pyx_L9_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":691 + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): + * raise TypeError("Cannot index with type '%s'" % type(item)) # <<<<<<<<<<<<<< + * + * have_slices = have_slices or isinstance(item, slice) + */ + __pyx_t_7 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Cannot_index_with_type_s, ((PyObject *)Py_TYPE(__pyx_v_item))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_11, 0, 0, 0); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __PYX_ERR(1, 691, __pyx_L1_error) + + /* "View.MemoryView":690 + * have_slices = True + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + */ + } + + /* "View.MemoryView":693 + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + * have_slices = have_slices or isinstance(item, slice) # <<<<<<<<<<<<<< + * result.append(item) + * + */ + __pyx_t_10 = (__pyx_v_have_slices != 0); + if (!__pyx_t_10) { + } else { + __pyx_t_1 = __pyx_t_10; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_10 = PySlice_Check(__pyx_v_item); + __pyx_t_2 = (__pyx_t_10 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L11_bool_binop_done:; + __pyx_v_have_slices = __pyx_t_1; + + /* "View.MemoryView":694 + * + * have_slices = have_slices or isinstance(item, slice) + * result.append(item) # <<<<<<<<<<<<<< + * + * nslices = ndim - len(result) + */ + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_v_item); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 694, __pyx_L1_error) + } + __pyx_L6:; + + /* "View.MemoryView":681 + * have_slices = False + * seen_ellipsis = False + * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< + * if item is Ellipsis: + * if not seen_ellipsis: + */ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":696 + * result.append(item) + * + * nslices = ndim - len(result) # <<<<<<<<<<<<<< + * if nslices: + * result.extend([slice(None)] * nslices) + */ + __pyx_t_5 = PyList_GET_SIZE(__pyx_v_result); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 696, __pyx_L1_error) + __pyx_v_nslices = (__pyx_v_ndim - __pyx_t_5); + + /* "View.MemoryView":697 + * + * nslices = ndim - len(result) + * if nslices: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * nslices) + * + */ + __pyx_t_1 = (__pyx_v_nslices != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":698 + * nslices = ndim - len(result) + * if nslices: + * result.extend([slice(None)] * nslices) # <<<<<<<<<<<<<< + * + * return have_slices or nslices, tuple(result) + */ + __pyx_t_3 = PyList_New(1 * ((__pyx_v_nslices<0) ? 0:__pyx_v_nslices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 698, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < __pyx_v_nslices; __pyx_temp++) { + __Pyx_INCREF(__pyx_slice__20); + __Pyx_GIVEREF(__pyx_slice__20); + PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_slice__20); + } + } + __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 698, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":697 + * + * nslices = ndim - len(result) + * if nslices: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * nslices) + * + */ + } + + /* "View.MemoryView":700 + * result.extend([slice(None)] * nslices) + * + * return have_slices or nslices, tuple(result) # <<<<<<<<<<<<<< + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + */ + __Pyx_XDECREF(__pyx_r); + if (!__pyx_v_have_slices) { + } else { + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L14_bool_binop_done; + } + __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_L14_bool_binop_done:; + __pyx_t_4 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_4); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_r = ((PyObject*)__pyx_t_11); + __pyx_t_11 = 0; + goto __pyx_L0; + + /* "View.MemoryView":668 + * return isinstance(o, memoryview) + * + * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< + * """ + * Replace all ellipses with full slices and fill incomplete indices with + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("View.MemoryView._unellipsify", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_tup); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_idx); + __Pyx_XDECREF(__pyx_v_item); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":702 + * return have_slices or nslices, tuple(result) + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + */ + +static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __pyx_v_ndim) { + Py_ssize_t __pyx_v_suboffset; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t *__pyx_t_1; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("assert_direct_dimensions", 0); + + /* "View.MemoryView":703 + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * for suboffset in suboffsets[:ndim]: # <<<<<<<<<<<<<< + * if suboffset >= 0: + * raise ValueError("Indirect dimensions not supported") + */ + __pyx_t_2 = (__pyx_v_suboffsets + __pyx_v_ndim); + for (__pyx_t_3 = __pyx_v_suboffsets; __pyx_t_3 < __pyx_t_2; __pyx_t_3++) { + __pyx_t_1 = __pyx_t_3; + __pyx_v_suboffset = (__pyx_t_1[0]); + + /* "View.MemoryView":704 + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * raise ValueError("Indirect dimensions not supported") + * + */ + __pyx_t_4 = ((__pyx_v_suboffset >= 0) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":705 + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + * raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__21, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(1, 705, __pyx_L1_error) + + /* "View.MemoryView":704 + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * raise ValueError("Indirect dimensions not supported") + * + */ + } + } + + /* "View.MemoryView":702 + * return have_slices or nslices, tuple(result) + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.assert_direct_dimensions", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":712 + * + * @cname('__pyx_memview_slice') + * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< + * cdef int new_ndim = 0, suboffset_dim = -1, dim + * cdef bint negative_step + */ + +static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *__pyx_v_memview, PyObject *__pyx_v_indices) { + int __pyx_v_new_ndim; + int __pyx_v_suboffset_dim; + int __pyx_v_dim; + __Pyx_memviewslice __pyx_v_src; + __Pyx_memviewslice __pyx_v_dst; + __Pyx_memviewslice *__pyx_v_p_src; + struct __pyx_memoryviewslice_obj *__pyx_v_memviewsliceobj = 0; + __Pyx_memviewslice *__pyx_v_p_dst; + int *__pyx_v_p_suboffset_dim; + Py_ssize_t __pyx_v_start; + Py_ssize_t __pyx_v_stop; + Py_ssize_t __pyx_v_step; + int __pyx_v_have_start; + int __pyx_v_have_stop; + int __pyx_v_have_step; + PyObject *__pyx_v_index = NULL; + struct __pyx_memoryview_obj *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + struct __pyx_memoryview_obj *__pyx_t_4; + char *__pyx_t_5; + int __pyx_t_6; + Py_ssize_t __pyx_t_7; + PyObject *(*__pyx_t_8)(PyObject *); + PyObject *__pyx_t_9 = NULL; + Py_ssize_t __pyx_t_10; + int __pyx_t_11; + Py_ssize_t __pyx_t_12; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memview_slice", 0); + + /* "View.MemoryView":713 + * @cname('__pyx_memview_slice') + * cdef memoryview memview_slice(memoryview memview, object indices): + * cdef int new_ndim = 0, suboffset_dim = -1, dim # <<<<<<<<<<<<<< + * cdef bint negative_step + * cdef __Pyx_memviewslice src, dst + */ + __pyx_v_new_ndim = 0; + __pyx_v_suboffset_dim = -1; + + /* "View.MemoryView":720 + * + * + * memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<< + * + * cdef _memoryviewslice memviewsliceobj + */ + (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst)))); + + /* "View.MemoryView":724 + * cdef _memoryviewslice memviewsliceobj + * + * assert memview.view.ndim > 0 # <<<<<<<<<<<<<< + * + * if isinstance(memview, _memoryviewslice): + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!((__pyx_v_memview->view.ndim > 0) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + __PYX_ERR(1, 724, __pyx_L1_error) + } + } + #endif + + /* "View.MemoryView":726 + * assert memview.view.ndim > 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":727 + * + * if isinstance(memview, _memoryviewslice): + * memviewsliceobj = memview # <<<<<<<<<<<<<< + * p_src = &memviewsliceobj.from_slice + * else: + */ + if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 727, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_v_memview); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":728 + * if isinstance(memview, _memoryviewslice): + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice # <<<<<<<<<<<<<< + * else: + * slice_copy(memview, &src) + */ + __pyx_v_p_src = (&__pyx_v_memviewsliceobj->from_slice); + + /* "View.MemoryView":726 + * assert memview.view.ndim > 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice + */ + goto __pyx_L3; + } + + /* "View.MemoryView":730 + * p_src = &memviewsliceobj.from_slice + * else: + * slice_copy(memview, &src) # <<<<<<<<<<<<<< + * p_src = &src + * + */ + /*else*/ { + __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_src)); + + /* "View.MemoryView":731 + * else: + * slice_copy(memview, &src) + * p_src = &src # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_p_src = (&__pyx_v_src); + } + __pyx_L3:; + + /* "View.MemoryView":737 + * + * + * dst.memview = p_src.memview # <<<<<<<<<<<<<< + * dst.data = p_src.data + * + */ + __pyx_t_4 = __pyx_v_p_src->memview; + __pyx_v_dst.memview = __pyx_t_4; + + /* "View.MemoryView":738 + * + * dst.memview = p_src.memview + * dst.data = p_src.data # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __pyx_v_p_src->data; + __pyx_v_dst.data = __pyx_t_5; + + /* "View.MemoryView":743 + * + * + * cdef __Pyx_memviewslice *p_dst = &dst # <<<<<<<<<<<<<< + * cdef int *p_suboffset_dim = &suboffset_dim + * cdef Py_ssize_t start, stop, step + */ + __pyx_v_p_dst = (&__pyx_v_dst); + + /* "View.MemoryView":744 + * + * cdef __Pyx_memviewslice *p_dst = &dst + * cdef int *p_suboffset_dim = &suboffset_dim # <<<<<<<<<<<<<< + * cdef Py_ssize_t start, stop, step + * cdef bint have_start, have_stop, have_step + */ + __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim); + + /* "View.MemoryView":748 + * cdef bint have_start, have_stop, have_step + * + * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< + * if PyIndex_Check(index): + * slice_memviewslice( + */ + __pyx_t_6 = 0; + if (likely(PyList_CheckExact(__pyx_v_indices)) || PyTuple_CheckExact(__pyx_v_indices)) { + __pyx_t_3 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_3); __pyx_t_7 = 0; + __pyx_t_8 = NULL; + } else { + __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 748, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_8)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_9 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(1, 748, __pyx_L1_error) + #else + __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + } else { + if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(1, 748, __pyx_L1_error) + #else + __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + } + } else { + __pyx_t_9 = __pyx_t_8(__pyx_t_3); + if (unlikely(!__pyx_t_9)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 748, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_9); + } + __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_v_dim = __pyx_t_6; + __pyx_t_6 = (__pyx_t_6 + 1); + + /* "View.MemoryView":749 + * + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): # <<<<<<<<<<<<<< + * slice_memviewslice( + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + */ + __pyx_t_2 = (PyIndex_Check(__pyx_v_index) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":753 + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + * dim, new_ndim, p_suboffset_dim, + * index, 0, 0, # start, stop, step # <<<<<<<<<<<<<< + * 0, 0, 0, # have_{start,stop,step} + * False) + */ + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 753, __pyx_L1_error) + + /* "View.MemoryView":750 + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): + * slice_memviewslice( # <<<<<<<<<<<<<< + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + * dim, new_ndim, p_suboffset_dim, + */ + __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_t_10, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 750, __pyx_L1_error) + + /* "View.MemoryView":749 + * + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): # <<<<<<<<<<<<<< + * slice_memviewslice( + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + */ + goto __pyx_L6; + } + + /* "View.MemoryView":756 + * 0, 0, 0, # have_{start,stop,step} + * False) + * elif index is None: # <<<<<<<<<<<<<< + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 + */ + __pyx_t_2 = (__pyx_v_index == Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":757 + * False) + * elif index is None: + * p_dst.shape[new_ndim] = 1 # <<<<<<<<<<<<<< + * p_dst.strides[new_ndim] = 0 + * p_dst.suboffsets[new_ndim] = -1 + */ + (__pyx_v_p_dst->shape[__pyx_v_new_ndim]) = 1; + + /* "View.MemoryView":758 + * elif index is None: + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 # <<<<<<<<<<<<<< + * p_dst.suboffsets[new_ndim] = -1 + * new_ndim += 1 + */ + (__pyx_v_p_dst->strides[__pyx_v_new_ndim]) = 0; + + /* "View.MemoryView":759 + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 + * p_dst.suboffsets[new_ndim] = -1 # <<<<<<<<<<<<<< + * new_ndim += 1 + * else: + */ + (__pyx_v_p_dst->suboffsets[__pyx_v_new_ndim]) = -1L; + + /* "View.MemoryView":760 + * p_dst.strides[new_ndim] = 0 + * p_dst.suboffsets[new_ndim] = -1 + * new_ndim += 1 # <<<<<<<<<<<<<< + * else: + * start = index.start or 0 + */ + __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); + + /* "View.MemoryView":756 + * 0, 0, 0, # have_{start,stop,step} + * False) + * elif index is None: # <<<<<<<<<<<<<< + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 + */ + goto __pyx_L6; + } + + /* "View.MemoryView":762 + * new_ndim += 1 + * else: + * start = index.start or 0 # <<<<<<<<<<<<<< + * stop = index.stop or 0 + * step = index.step or 0 + */ + /*else*/ { + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 762, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 762, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 762, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L7_bool_binop_done:; + __pyx_v_start = __pyx_t_10; + + /* "View.MemoryView":763 + * else: + * start = index.start or 0 + * stop = index.stop or 0 # <<<<<<<<<<<<<< + * step = index.step or 0 + * + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 763, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 763, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 763, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L9_bool_binop_done:; + __pyx_v_stop = __pyx_t_10; + + /* "View.MemoryView":764 + * start = index.start or 0 + * stop = index.stop or 0 + * step = index.step or 0 # <<<<<<<<<<<<<< + * + * have_start = index.start is not None + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 764, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 764, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 764, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L11_bool_binop_done:; + __pyx_v_step = __pyx_t_10; + + /* "View.MemoryView":766 + * step = index.step or 0 + * + * have_start = index.start is not None # <<<<<<<<<<<<<< + * have_stop = index.stop is not None + * have_step = index.step is not None + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 766, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_have_start = __pyx_t_1; + + /* "View.MemoryView":767 + * + * have_start = index.start is not None + * have_stop = index.stop is not None # <<<<<<<<<<<<<< + * have_step = index.step is not None + * + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 767, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_have_stop = __pyx_t_1; + + /* "View.MemoryView":768 + * have_start = index.start is not None + * have_stop = index.stop is not None + * have_step = index.step is not None # <<<<<<<<<<<<<< + * + * slice_memviewslice( + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 768, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_have_step = __pyx_t_1; + + /* "View.MemoryView":770 + * have_step = index.step is not None + * + * slice_memviewslice( # <<<<<<<<<<<<<< + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + * dim, new_ndim, p_suboffset_dim, + */ + __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_start, __pyx_v_stop, __pyx_v_step, __pyx_v_have_start, __pyx_v_have_stop, __pyx_v_have_step, 1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 770, __pyx_L1_error) + + /* "View.MemoryView":776 + * have_start, have_stop, have_step, + * True) + * new_ndim += 1 # <<<<<<<<<<<<<< + * + * if isinstance(memview, _memoryviewslice): + */ + __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); + } + __pyx_L6:; + + /* "View.MemoryView":748 + * cdef bint have_start, have_stop, have_step + * + * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< + * if PyIndex_Check(index): + * slice_memviewslice( + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":778 + * new_ndim += 1 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":779 + * + * if isinstance(memview, _memoryviewslice): + * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< + * memviewsliceobj.to_object_func, + * memviewsliceobj.to_dtype_func, + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + + /* "View.MemoryView":780 + * if isinstance(memview, _memoryviewslice): + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, # <<<<<<<<<<<<<< + * memviewsliceobj.to_dtype_func, + * memview.dtype_is_object) + */ + if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 780, __pyx_L1_error) } + + /* "View.MemoryView":781 + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, + * memviewsliceobj.to_dtype_func, # <<<<<<<<<<<<<< + * memview.dtype_is_object) + * else: + */ + if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 781, __pyx_L1_error) } + + /* "View.MemoryView":779 + * + * if isinstance(memview, _memoryviewslice): + * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< + * memviewsliceobj.to_object_func, + * memviewsliceobj.to_dtype_func, + */ + __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, __pyx_v_memviewsliceobj->to_object_func, __pyx_v_memviewsliceobj->to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 779, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 779, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":778 + * new_ndim += 1 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, + */ + } + + /* "View.MemoryView":784 + * memview.dtype_is_object) + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< + * memview.dtype_is_object) + * + */ + /*else*/ { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + + /* "View.MemoryView":785 + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, + * memview.dtype_is_object) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 784, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "View.MemoryView":784 + * memview.dtype_is_object) + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< + * memview.dtype_is_object) + * + */ + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 784, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":712 + * + * @cname('__pyx_memview_slice') + * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< + * cdef int new_ndim = 0, suboffset_dim = -1, dim + * cdef bint negative_step + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("View.MemoryView.memview_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_memviewsliceobj); + __Pyx_XDECREF(__pyx_v_index); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":809 + * + * @cname('__pyx_memoryview_slice_memviewslice') + * cdef int slice_memviewslice( # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, + */ + +static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, Py_ssize_t __pyx_v_shape, Py_ssize_t __pyx_v_stride, Py_ssize_t __pyx_v_suboffset, int __pyx_v_dim, int __pyx_v_new_ndim, int *__pyx_v_suboffset_dim, Py_ssize_t __pyx_v_start, Py_ssize_t __pyx_v_stop, Py_ssize_t __pyx_v_step, int __pyx_v_have_start, int __pyx_v_have_stop, int __pyx_v_have_step, int __pyx_v_is_slice) { + Py_ssize_t __pyx_v_new_shape; + int __pyx_v_negative_step; + int __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":829 + * cdef bint negative_step + * + * if not is_slice: # <<<<<<<<<<<<<< + * + * if start < 0: + */ + __pyx_t_1 = ((!(__pyx_v_is_slice != 0)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":831 + * if not is_slice: + * + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if not 0 <= start < shape: + */ + __pyx_t_1 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":832 + * + * if start < 0: + * start += shape # <<<<<<<<<<<<<< + * if not 0 <= start < shape: + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + */ + __pyx_v_start = (__pyx_v_start + __pyx_v_shape); + + /* "View.MemoryView":831 + * if not is_slice: + * + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if not 0 <= start < shape: + */ + } + + /* "View.MemoryView":833 + * if start < 0: + * start += shape + * if not 0 <= start < shape: # <<<<<<<<<<<<<< + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + * else: + */ + __pyx_t_1 = (0 <= __pyx_v_start); + if (__pyx_t_1) { + __pyx_t_1 = (__pyx_v_start < __pyx_v_shape); + } + __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":834 + * start += shape + * if not 0 <= start < shape: + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) # <<<<<<<<<<<<<< + * else: + * + */ + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"Index out of bounds (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 834, __pyx_L1_error) + + /* "View.MemoryView":833 + * if start < 0: + * start += shape + * if not 0 <= start < shape: # <<<<<<<<<<<<<< + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + * else: + */ + } + + /* "View.MemoryView":829 + * cdef bint negative_step + * + * if not is_slice: # <<<<<<<<<<<<<< + * + * if start < 0: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":837 + * else: + * + * negative_step = have_step != 0 and step < 0 # <<<<<<<<<<<<<< + * + * if have_step and step == 0: + */ + /*else*/ { + __pyx_t_1 = ((__pyx_v_have_step != 0) != 0); + if (__pyx_t_1) { + } else { + __pyx_t_2 = __pyx_t_1; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_1 = ((__pyx_v_step < 0) != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L6_bool_binop_done:; + __pyx_v_negative_step = __pyx_t_2; + + /* "View.MemoryView":839 + * negative_step = have_step != 0 and step < 0 + * + * if have_step and step == 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) + * + */ + __pyx_t_1 = (__pyx_v_have_step != 0); + if (__pyx_t_1) { + } else { + __pyx_t_2 = __pyx_t_1; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_1 = ((__pyx_v_step == 0) != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L9_bool_binop_done:; + if (__pyx_t_2) { + + /* "View.MemoryView":840 + * + * if have_step and step == 0: + * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Step may not be zero (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 840, __pyx_L1_error) + + /* "View.MemoryView":839 + * negative_step = have_step != 0 and step < 0 + * + * if have_step and step == 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) + * + */ + } + + /* "View.MemoryView":843 + * + * + * if have_start: # <<<<<<<<<<<<<< + * if start < 0: + * start += shape + */ + __pyx_t_2 = (__pyx_v_have_start != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":844 + * + * if have_start: + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if start < 0: + */ + __pyx_t_2 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":845 + * if have_start: + * if start < 0: + * start += shape # <<<<<<<<<<<<<< + * if start < 0: + * start = 0 + */ + __pyx_v_start = (__pyx_v_start + __pyx_v_shape); + + /* "View.MemoryView":846 + * if start < 0: + * start += shape + * if start < 0: # <<<<<<<<<<<<<< + * start = 0 + * elif start >= shape: + */ + __pyx_t_2 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":847 + * start += shape + * if start < 0: + * start = 0 # <<<<<<<<<<<<<< + * elif start >= shape: + * if negative_step: + */ + __pyx_v_start = 0; + + /* "View.MemoryView":846 + * if start < 0: + * start += shape + * if start < 0: # <<<<<<<<<<<<<< + * start = 0 + * elif start >= shape: + */ + } + + /* "View.MemoryView":844 + * + * if have_start: + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if start < 0: + */ + goto __pyx_L12; + } + + /* "View.MemoryView":848 + * if start < 0: + * start = 0 + * elif start >= shape: # <<<<<<<<<<<<<< + * if negative_step: + * start = shape - 1 + */ + __pyx_t_2 = ((__pyx_v_start >= __pyx_v_shape) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":849 + * start = 0 + * elif start >= shape: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":850 + * elif start >= shape: + * if negative_step: + * start = shape - 1 # <<<<<<<<<<<<<< + * else: + * start = shape + */ + __pyx_v_start = (__pyx_v_shape - 1); + + /* "View.MemoryView":849 + * start = 0 + * elif start >= shape: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + goto __pyx_L14; + } + + /* "View.MemoryView":852 + * start = shape - 1 + * else: + * start = shape # <<<<<<<<<<<<<< + * else: + * if negative_step: + */ + /*else*/ { + __pyx_v_start = __pyx_v_shape; + } + __pyx_L14:; + + /* "View.MemoryView":848 + * if start < 0: + * start = 0 + * elif start >= shape: # <<<<<<<<<<<<<< + * if negative_step: + * start = shape - 1 + */ + } + __pyx_L12:; + + /* "View.MemoryView":843 + * + * + * if have_start: # <<<<<<<<<<<<<< + * if start < 0: + * start += shape + */ + goto __pyx_L11; + } + + /* "View.MemoryView":854 + * start = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + /*else*/ { + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":855 + * else: + * if negative_step: + * start = shape - 1 # <<<<<<<<<<<<<< + * else: + * start = 0 + */ + __pyx_v_start = (__pyx_v_shape - 1); + + /* "View.MemoryView":854 + * start = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + goto __pyx_L15; + } + + /* "View.MemoryView":857 + * start = shape - 1 + * else: + * start = 0 # <<<<<<<<<<<<<< + * + * if have_stop: + */ + /*else*/ { + __pyx_v_start = 0; + } + __pyx_L15:; + } + __pyx_L11:; + + /* "View.MemoryView":859 + * start = 0 + * + * if have_stop: # <<<<<<<<<<<<<< + * if stop < 0: + * stop += shape + */ + __pyx_t_2 = (__pyx_v_have_stop != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":860 + * + * if have_stop: + * if stop < 0: # <<<<<<<<<<<<<< + * stop += shape + * if stop < 0: + */ + __pyx_t_2 = ((__pyx_v_stop < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":861 + * if have_stop: + * if stop < 0: + * stop += shape # <<<<<<<<<<<<<< + * if stop < 0: + * stop = 0 + */ + __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape); + + /* "View.MemoryView":862 + * if stop < 0: + * stop += shape + * if stop < 0: # <<<<<<<<<<<<<< + * stop = 0 + * elif stop > shape: + */ + __pyx_t_2 = ((__pyx_v_stop < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":863 + * stop += shape + * if stop < 0: + * stop = 0 # <<<<<<<<<<<<<< + * elif stop > shape: + * stop = shape + */ + __pyx_v_stop = 0; + + /* "View.MemoryView":862 + * if stop < 0: + * stop += shape + * if stop < 0: # <<<<<<<<<<<<<< + * stop = 0 + * elif stop > shape: + */ + } + + /* "View.MemoryView":860 + * + * if have_stop: + * if stop < 0: # <<<<<<<<<<<<<< + * stop += shape + * if stop < 0: + */ + goto __pyx_L17; + } + + /* "View.MemoryView":864 + * if stop < 0: + * stop = 0 + * elif stop > shape: # <<<<<<<<<<<<<< + * stop = shape + * else: + */ + __pyx_t_2 = ((__pyx_v_stop > __pyx_v_shape) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":865 + * stop = 0 + * elif stop > shape: + * stop = shape # <<<<<<<<<<<<<< + * else: + * if negative_step: + */ + __pyx_v_stop = __pyx_v_shape; + + /* "View.MemoryView":864 + * if stop < 0: + * stop = 0 + * elif stop > shape: # <<<<<<<<<<<<<< + * stop = shape + * else: + */ + } + __pyx_L17:; + + /* "View.MemoryView":859 + * start = 0 + * + * if have_stop: # <<<<<<<<<<<<<< + * if stop < 0: + * stop += shape + */ + goto __pyx_L16; + } + + /* "View.MemoryView":867 + * stop = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * stop = -1 + * else: + */ + /*else*/ { + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":868 + * else: + * if negative_step: + * stop = -1 # <<<<<<<<<<<<<< + * else: + * stop = shape + */ + __pyx_v_stop = -1L; + + /* "View.MemoryView":867 + * stop = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * stop = -1 + * else: + */ + goto __pyx_L19; + } + + /* "View.MemoryView":870 + * stop = -1 + * else: + * stop = shape # <<<<<<<<<<<<<< + * + * if not have_step: + */ + /*else*/ { + __pyx_v_stop = __pyx_v_shape; + } + __pyx_L19:; + } + __pyx_L16:; + + /* "View.MemoryView":872 + * stop = shape + * + * if not have_step: # <<<<<<<<<<<<<< + * step = 1 + * + */ + __pyx_t_2 = ((!(__pyx_v_have_step != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":873 + * + * if not have_step: + * step = 1 # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_step = 1; + + /* "View.MemoryView":872 + * stop = shape + * + * if not have_step: # <<<<<<<<<<<<<< + * step = 1 + * + */ + } + + /* "View.MemoryView":877 + * + * with cython.cdivision(True): + * new_shape = (stop - start) // step # <<<<<<<<<<<<<< + * + * if (stop - start) - step * new_shape: + */ + __pyx_v_new_shape = ((__pyx_v_stop - __pyx_v_start) / __pyx_v_step); + + /* "View.MemoryView":879 + * new_shape = (stop - start) // step + * + * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< + * new_shape += 1 + * + */ + __pyx_t_2 = (((__pyx_v_stop - __pyx_v_start) - (__pyx_v_step * __pyx_v_new_shape)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":880 + * + * if (stop - start) - step * new_shape: + * new_shape += 1 # <<<<<<<<<<<<<< + * + * if new_shape < 0: + */ + __pyx_v_new_shape = (__pyx_v_new_shape + 1); + + /* "View.MemoryView":879 + * new_shape = (stop - start) // step + * + * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< + * new_shape += 1 + * + */ + } + + /* "View.MemoryView":882 + * new_shape += 1 + * + * if new_shape < 0: # <<<<<<<<<<<<<< + * new_shape = 0 + * + */ + __pyx_t_2 = ((__pyx_v_new_shape < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":883 + * + * if new_shape < 0: + * new_shape = 0 # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_new_shape = 0; + + /* "View.MemoryView":882 + * new_shape += 1 + * + * if new_shape < 0: # <<<<<<<<<<<<<< + * new_shape = 0 + * + */ + } + + /* "View.MemoryView":886 + * + * + * dst.strides[new_ndim] = stride * step # <<<<<<<<<<<<<< + * dst.shape[new_ndim] = new_shape + * dst.suboffsets[new_ndim] = suboffset + */ + (__pyx_v_dst->strides[__pyx_v_new_ndim]) = (__pyx_v_stride * __pyx_v_step); + + /* "View.MemoryView":887 + * + * dst.strides[new_ndim] = stride * step + * dst.shape[new_ndim] = new_shape # <<<<<<<<<<<<<< + * dst.suboffsets[new_ndim] = suboffset + * + */ + (__pyx_v_dst->shape[__pyx_v_new_ndim]) = __pyx_v_new_shape; + + /* "View.MemoryView":888 + * dst.strides[new_ndim] = stride * step + * dst.shape[new_ndim] = new_shape + * dst.suboffsets[new_ndim] = suboffset # <<<<<<<<<<<<<< + * + * + */ + (__pyx_v_dst->suboffsets[__pyx_v_new_ndim]) = __pyx_v_suboffset; + } + __pyx_L3:; + + /* "View.MemoryView":891 + * + * + * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< + * dst.data += start * stride + * else: + */ + __pyx_t_2 = (((__pyx_v_suboffset_dim[0]) < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":892 + * + * if suboffset_dim[0] < 0: + * dst.data += start * stride # <<<<<<<<<<<<<< + * else: + * dst.suboffsets[suboffset_dim[0]] += start * stride + */ + __pyx_v_dst->data = (__pyx_v_dst->data + (__pyx_v_start * __pyx_v_stride)); + + /* "View.MemoryView":891 + * + * + * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< + * dst.data += start * stride + * else: + */ + goto __pyx_L23; + } + + /* "View.MemoryView":894 + * dst.data += start * stride + * else: + * dst.suboffsets[suboffset_dim[0]] += start * stride # <<<<<<<<<<<<<< + * + * if suboffset >= 0: + */ + /*else*/ { + __pyx_t_3 = (__pyx_v_suboffset_dim[0]); + (__pyx_v_dst->suboffsets[__pyx_t_3]) = ((__pyx_v_dst->suboffsets[__pyx_t_3]) + (__pyx_v_start * __pyx_v_stride)); + } + __pyx_L23:; + + /* "View.MemoryView":896 + * dst.suboffsets[suboffset_dim[0]] += start * stride + * + * if suboffset >= 0: # <<<<<<<<<<<<<< + * if not is_slice: + * if new_ndim == 0: + */ + __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":897 + * + * if suboffset >= 0: + * if not is_slice: # <<<<<<<<<<<<<< + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset + */ + __pyx_t_2 = ((!(__pyx_v_is_slice != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":898 + * if suboffset >= 0: + * if not is_slice: + * if new_ndim == 0: # <<<<<<<<<<<<<< + * dst.data = ( dst.data)[0] + suboffset + * else: + */ + __pyx_t_2 = ((__pyx_v_new_ndim == 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":899 + * if not is_slice: + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset # <<<<<<<<<<<<<< + * else: + * _err_dim(IndexError, "All dimensions preceding dimension %d " + */ + __pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset); + + /* "View.MemoryView":898 + * if suboffset >= 0: + * if not is_slice: + * if new_ndim == 0: # <<<<<<<<<<<<<< + * dst.data = ( dst.data)[0] + suboffset + * else: + */ + goto __pyx_L26; + } + + /* "View.MemoryView":901 + * dst.data = ( dst.data)[0] + suboffset + * else: + * _err_dim(IndexError, "All dimensions preceding dimension %d " # <<<<<<<<<<<<<< + * "must be indexed and not sliced", dim) + * else: + */ + /*else*/ { + + /* "View.MemoryView":902 + * else: + * _err_dim(IndexError, "All dimensions preceding dimension %d " + * "must be indexed and not sliced", dim) # <<<<<<<<<<<<<< + * else: + * suboffset_dim[0] = new_ndim + */ + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"All dimensions preceding dimension %d must be indexed and not sliced"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 901, __pyx_L1_error) + } + __pyx_L26:; + + /* "View.MemoryView":897 + * + * if suboffset >= 0: + * if not is_slice: # <<<<<<<<<<<<<< + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset + */ + goto __pyx_L25; + } + + /* "View.MemoryView":904 + * "must be indexed and not sliced", dim) + * else: + * suboffset_dim[0] = new_ndim # <<<<<<<<<<<<<< + * + * return 0 + */ + /*else*/ { + (__pyx_v_suboffset_dim[0]) = __pyx_v_new_ndim; + } + __pyx_L25:; + + /* "View.MemoryView":896 + * dst.suboffsets[suboffset_dim[0]] += start * stride + * + * if suboffset >= 0: # <<<<<<<<<<<<<< + * if not is_slice: + * if new_ndim == 0: + */ + } + + /* "View.MemoryView":906 + * suboffset_dim[0] = new_ndim + * + * return 0 # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":809 + * + * @cname('__pyx_memoryview_slice_memviewslice') + * cdef int slice_memviewslice( # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.slice_memviewslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":912 + * + * @cname('__pyx_pybuffer_index') + * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 + */ + +static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, Py_ssize_t __pyx_v_index, Py_ssize_t __pyx_v_dim) { + Py_ssize_t __pyx_v_shape; + Py_ssize_t __pyx_v_stride; + Py_ssize_t __pyx_v_suboffset; + Py_ssize_t __pyx_v_itemsize; + char *__pyx_v_resultp; + char *__pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("pybuffer_index", 0); + + /* "View.MemoryView":914 + * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 # <<<<<<<<<<<<<< + * cdef Py_ssize_t itemsize = view.itemsize + * cdef char *resultp + */ + __pyx_v_suboffset = -1L; + + /* "View.MemoryView":915 + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 + * cdef Py_ssize_t itemsize = view.itemsize # <<<<<<<<<<<<<< + * cdef char *resultp + * + */ + __pyx_t_1 = __pyx_v_view->itemsize; + __pyx_v_itemsize = __pyx_t_1; + + /* "View.MemoryView":918 + * cdef char *resultp + * + * if view.ndim == 0: # <<<<<<<<<<<<<< + * shape = view.len / itemsize + * stride = itemsize + */ + __pyx_t_2 = ((__pyx_v_view->ndim == 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":919 + * + * if view.ndim == 0: + * shape = view.len / itemsize # <<<<<<<<<<<<<< + * stride = itemsize + * else: + */ + if (unlikely(__pyx_v_itemsize == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); + __PYX_ERR(1, 919, __pyx_L1_error) + } + else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_view->len))) { + PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); + __PYX_ERR(1, 919, __pyx_L1_error) + } + __pyx_v_shape = __Pyx_div_Py_ssize_t(__pyx_v_view->len, __pyx_v_itemsize); + + /* "View.MemoryView":920 + * if view.ndim == 0: + * shape = view.len / itemsize + * stride = itemsize # <<<<<<<<<<<<<< + * else: + * shape = view.shape[dim] + */ + __pyx_v_stride = __pyx_v_itemsize; + + /* "View.MemoryView":918 + * cdef char *resultp + * + * if view.ndim == 0: # <<<<<<<<<<<<<< + * shape = view.len / itemsize + * stride = itemsize + */ + goto __pyx_L3; + } + + /* "View.MemoryView":922 + * stride = itemsize + * else: + * shape = view.shape[dim] # <<<<<<<<<<<<<< + * stride = view.strides[dim] + * if view.suboffsets != NULL: + */ + /*else*/ { + __pyx_v_shape = (__pyx_v_view->shape[__pyx_v_dim]); + + /* "View.MemoryView":923 + * else: + * shape = view.shape[dim] + * stride = view.strides[dim] # <<<<<<<<<<<<<< + * if view.suboffsets != NULL: + * suboffset = view.suboffsets[dim] + */ + __pyx_v_stride = (__pyx_v_view->strides[__pyx_v_dim]); + + /* "View.MemoryView":924 + * shape = view.shape[dim] + * stride = view.strides[dim] + * if view.suboffsets != NULL: # <<<<<<<<<<<<<< + * suboffset = view.suboffsets[dim] + * + */ + __pyx_t_2 = ((__pyx_v_view->suboffsets != NULL) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":925 + * stride = view.strides[dim] + * if view.suboffsets != NULL: + * suboffset = view.suboffsets[dim] # <<<<<<<<<<<<<< + * + * if index < 0: + */ + __pyx_v_suboffset = (__pyx_v_view->suboffsets[__pyx_v_dim]); + + /* "View.MemoryView":924 + * shape = view.shape[dim] + * stride = view.strides[dim] + * if view.suboffsets != NULL: # <<<<<<<<<<<<<< + * suboffset = view.suboffsets[dim] + * + */ + } + } + __pyx_L3:; + + /* "View.MemoryView":927 + * suboffset = view.suboffsets[dim] + * + * if index < 0: # <<<<<<<<<<<<<< + * index += view.shape[dim] + * if index < 0: + */ + __pyx_t_2 = ((__pyx_v_index < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":928 + * + * if index < 0: + * index += view.shape[dim] # <<<<<<<<<<<<<< + * if index < 0: + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + */ + __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim])); + + /* "View.MemoryView":929 + * if index < 0: + * index += view.shape[dim] + * if index < 0: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + __pyx_t_2 = ((__pyx_v_index < 0) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":930 + * index += view.shape[dim] + * if index < 0: + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<< + * + * if index >= shape: + */ + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 930, __pyx_L1_error) + + /* "View.MemoryView":929 + * if index < 0: + * index += view.shape[dim] + * if index < 0: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + } + + /* "View.MemoryView":927 + * suboffset = view.suboffsets[dim] + * + * if index < 0: # <<<<<<<<<<<<<< + * index += view.shape[dim] + * if index < 0: + */ + } + + /* "View.MemoryView":932 + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + * if index >= shape: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + __pyx_t_2 = ((__pyx_v_index >= __pyx_v_shape) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":933 + * + * if index >= shape: + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<< + * + * resultp = bufp + index * stride + */ + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 933, __pyx_L1_error) + + /* "View.MemoryView":932 + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + * if index >= shape: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + } + + /* "View.MemoryView":935 + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + * resultp = bufp + index * stride # <<<<<<<<<<<<<< + * if suboffset >= 0: + * resultp = ( resultp)[0] + suboffset + */ + __pyx_v_resultp = (__pyx_v_bufp + (__pyx_v_index * __pyx_v_stride)); + + /* "View.MemoryView":936 + * + * resultp = bufp + index * stride + * if suboffset >= 0: # <<<<<<<<<<<<<< + * resultp = ( resultp)[0] + suboffset + * + */ + __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":937 + * resultp = bufp + index * stride + * if suboffset >= 0: + * resultp = ( resultp)[0] + suboffset # <<<<<<<<<<<<<< + * + * return resultp + */ + __pyx_v_resultp = ((((char **)__pyx_v_resultp)[0]) + __pyx_v_suboffset); + + /* "View.MemoryView":936 + * + * resultp = bufp + index * stride + * if suboffset >= 0: # <<<<<<<<<<<<<< + * resultp = ( resultp)[0] + suboffset + * + */ + } + + /* "View.MemoryView":939 + * resultp = ( resultp)[0] + suboffset + * + * return resultp # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_resultp; + goto __pyx_L0; + + /* "View.MemoryView":912 + * + * @cname('__pyx_pybuffer_index') + * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView.pybuffer_index", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":945 + * + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< + * cdef int ndim = memslice.memview.view.ndim + * + */ + +static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { + int __pyx_v_ndim; + Py_ssize_t *__pyx_v_shape; + Py_ssize_t *__pyx_v_strides; + int __pyx_v_i; + int __pyx_v_j; + int __pyx_r; + int __pyx_t_1; + Py_ssize_t *__pyx_t_2; + long __pyx_t_3; + long __pyx_t_4; + Py_ssize_t __pyx_t_5; + Py_ssize_t __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":946 + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: + * cdef int ndim = memslice.memview.view.ndim # <<<<<<<<<<<<<< + * + * cdef Py_ssize_t *shape = memslice.shape + */ + __pyx_t_1 = __pyx_v_memslice->memview->view.ndim; + __pyx_v_ndim = __pyx_t_1; + + /* "View.MemoryView":948 + * cdef int ndim = memslice.memview.view.ndim + * + * cdef Py_ssize_t *shape = memslice.shape # <<<<<<<<<<<<<< + * cdef Py_ssize_t *strides = memslice.strides + * + */ + __pyx_t_2 = __pyx_v_memslice->shape; + __pyx_v_shape = __pyx_t_2; + + /* "View.MemoryView":949 + * + * cdef Py_ssize_t *shape = memslice.shape + * cdef Py_ssize_t *strides = memslice.strides # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __pyx_v_memslice->strides; + __pyx_v_strides = __pyx_t_2; + + /* "View.MemoryView":953 + * + * cdef int i, j + * for i in range(ndim / 2): # <<<<<<<<<<<<<< + * j = ndim - 1 - i + * strides[i], strides[j] = strides[j], strides[i] + */ + __pyx_t_3 = __Pyx_div_long(__pyx_v_ndim, 2); + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_1 = 0; __pyx_t_1 < __pyx_t_4; __pyx_t_1+=1) { + __pyx_v_i = __pyx_t_1; + + /* "View.MemoryView":954 + * cdef int i, j + * for i in range(ndim / 2): + * j = ndim - 1 - i # <<<<<<<<<<<<<< + * strides[i], strides[j] = strides[j], strides[i] + * shape[i], shape[j] = shape[j], shape[i] + */ + __pyx_v_j = ((__pyx_v_ndim - 1) - __pyx_v_i); + + /* "View.MemoryView":955 + * for i in range(ndim / 2): + * j = ndim - 1 - i + * strides[i], strides[j] = strides[j], strides[i] # <<<<<<<<<<<<<< + * shape[i], shape[j] = shape[j], shape[i] + * + */ + __pyx_t_5 = (__pyx_v_strides[__pyx_v_j]); + __pyx_t_6 = (__pyx_v_strides[__pyx_v_i]); + (__pyx_v_strides[__pyx_v_i]) = __pyx_t_5; + (__pyx_v_strides[__pyx_v_j]) = __pyx_t_6; + + /* "View.MemoryView":956 + * j = ndim - 1 - i + * strides[i], strides[j] = strides[j], strides[i] + * shape[i], shape[j] = shape[j], shape[i] # <<<<<<<<<<<<<< + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: + */ + __pyx_t_6 = (__pyx_v_shape[__pyx_v_j]); + __pyx_t_5 = (__pyx_v_shape[__pyx_v_i]); + (__pyx_v_shape[__pyx_v_i]) = __pyx_t_6; + (__pyx_v_shape[__pyx_v_j]) = __pyx_t_5; + + /* "View.MemoryView":958 + * shape[i], shape[j] = shape[j], shape[i] + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + */ + __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 0) != 0); + if (!__pyx_t_8) { + } else { + __pyx_t_7 = __pyx_t_8; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_j]) >= 0) != 0); + __pyx_t_7 = __pyx_t_8; + __pyx_L6_bool_binop_done:; + if (__pyx_t_7) { + + /* "View.MemoryView":959 + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") # <<<<<<<<<<<<<< + * + * return 1 + */ + __pyx_t_9 = __pyx_memoryview_err(__pyx_builtin_ValueError, ((char *)"Cannot transpose memoryview with indirect dimensions")); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 959, __pyx_L1_error) + + /* "View.MemoryView":958 + * shape[i], shape[j] = shape[j], shape[i] + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + */ + } + } + + /* "View.MemoryView":961 + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + * return 1 # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = 1; + goto __pyx_L0; + + /* "View.MemoryView":945 + * + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< + * cdef int ndim = memslice.memview.view.ndim + * + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.transpose_memslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = 0; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":978 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + */ + +/* Python wrapper */ +static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":979 + * + * def __dealloc__(self): + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<< + * + * cdef convert_item_to_object(self, char *itemp): + */ + __PYX_XDEC_MEMVIEW((&__pyx_v_self->from_slice), 1); + + /* "View.MemoryView":978 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":981 + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * if self.to_object_func != NULL: + * return self.to_object_func(itemp) + */ + +static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("convert_item_to_object", 0); + + /* "View.MemoryView":982 + * + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: # <<<<<<<<<<<<<< + * return self.to_object_func(itemp) + * else: + */ + __pyx_t_1 = ((__pyx_v_self->to_object_func != NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":983 + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: + * return self.to_object_func(itemp) # <<<<<<<<<<<<<< + * else: + * return memoryview.convert_item_to_object(self, itemp) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_v_self->to_object_func(__pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 983, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":982 + * + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: # <<<<<<<<<<<<<< + * return self.to_object_func(itemp) + * else: + */ + } + + /* "View.MemoryView":985 + * return self.to_object_func(itemp) + * else: + * return memoryview.convert_item_to_object(self, itemp) # <<<<<<<<<<<<<< + * + * cdef assign_item_from_object(self, char *itemp, object value): + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_memoryview_convert_item_to_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 985, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":981 + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * if self.to_object_func != NULL: + * return self.to_object_func(itemp) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":987 + * return memoryview.convert_item_to_object(self, itemp) + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * if self.to_dtype_func != NULL: + * self.to_dtype_func(itemp, value) + */ + +static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("assign_item_from_object", 0); + + /* "View.MemoryView":988 + * + * cdef assign_item_from_object(self, char *itemp, object value): + * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< + * self.to_dtype_func(itemp, value) + * else: + */ + __pyx_t_1 = ((__pyx_v_self->to_dtype_func != NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":989 + * cdef assign_item_from_object(self, char *itemp, object value): + * if self.to_dtype_func != NULL: + * self.to_dtype_func(itemp, value) # <<<<<<<<<<<<<< + * else: + * memoryview.assign_item_from_object(self, itemp, value) + */ + __pyx_t_2 = __pyx_v_self->to_dtype_func(__pyx_v_itemp, __pyx_v_value); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 989, __pyx_L1_error) + + /* "View.MemoryView":988 + * + * cdef assign_item_from_object(self, char *itemp, object value): + * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< + * self.to_dtype_func(itemp, value) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":991 + * self.to_dtype_func(itemp, value) + * else: + * memoryview.assign_item_from_object(self, itemp, value) # <<<<<<<<<<<<<< + * + * @property + */ + /*else*/ { + __pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 991, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L3:; + + /* "View.MemoryView":987 + * return memoryview.convert_item_to_object(self, itemp) + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * if self.to_dtype_func != NULL: + * self.to_dtype_func(itemp, value) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":994 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.from_object + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":995 + * @property + * def base(self): + * return self.from_object # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->from_object); + __pyx_r = __pyx_v_self->from_object; + goto __pyx_L0; + + /* "View.MemoryView":994 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.from_object + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_memoryviewslice___reduce_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__22, 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__23, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1001 + * + * @cname('__pyx_memoryview_fromslice') + * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< + * int ndim, + * object (*to_object_func)(char *), + */ + +static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewslice, int __pyx_v_ndim, PyObject *(*__pyx_v_to_object_func)(char *), int (*__pyx_v_to_dtype_func)(char *, PyObject *), int __pyx_v_dtype_is_object) { + struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; + Py_ssize_t __pyx_v_suboffset; + PyObject *__pyx_v_length = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_TypeInfo *__pyx_t_4; + Py_buffer __pyx_t_5; + Py_ssize_t *__pyx_t_6; + Py_ssize_t *__pyx_t_7; + Py_ssize_t *__pyx_t_8; + Py_ssize_t __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_fromslice", 0); + + /* "View.MemoryView":1009 + * cdef _memoryviewslice result + * + * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< + * return None + * + */ + __pyx_t_1 = ((((PyObject *)__pyx_v_memviewslice.memview) == Py_None) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1010 + * + * if memviewslice.memview == Py_None: + * return None # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "View.MemoryView":1009 + * cdef _memoryviewslice result + * + * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< + * return None + * + */ + } + + /* "View.MemoryView":1015 + * + * + * result = _memoryviewslice(None, 0, dtype_is_object) # <<<<<<<<<<<<<< + * + * result.from_slice = memviewslice + */ + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1015, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1015, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1015, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":1017 + * result = _memoryviewslice(None, 0, dtype_is_object) + * + * result.from_slice = memviewslice # <<<<<<<<<<<<<< + * __PYX_INC_MEMVIEW(&memviewslice, 1) + * + */ + __pyx_v_result->from_slice = __pyx_v_memviewslice; + + /* "View.MemoryView":1018 + * + * result.from_slice = memviewslice + * __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<< + * + * result.from_object = ( memviewslice.memview).base + */ + __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1); + + /* "View.MemoryView":1020 + * __PYX_INC_MEMVIEW(&memviewslice, 1) + * + * result.from_object = ( memviewslice.memview).base # <<<<<<<<<<<<<< + * result.typeinfo = memviewslice.memview.typeinfo + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_memviewslice.memview), __pyx_n_s_base); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1020, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_result->from_object); + __Pyx_DECREF(__pyx_v_result->from_object); + __pyx_v_result->from_object = __pyx_t_2; + __pyx_t_2 = 0; + + /* "View.MemoryView":1021 + * + * result.from_object = ( memviewslice.memview).base + * result.typeinfo = memviewslice.memview.typeinfo # <<<<<<<<<<<<<< + * + * result.view = memviewslice.memview.view + */ + __pyx_t_4 = __pyx_v_memviewslice.memview->typeinfo; + __pyx_v_result->__pyx_base.typeinfo = __pyx_t_4; + + /* "View.MemoryView":1023 + * result.typeinfo = memviewslice.memview.typeinfo + * + * result.view = memviewslice.memview.view # <<<<<<<<<<<<<< + * result.view.buf = memviewslice.data + * result.view.ndim = ndim + */ + __pyx_t_5 = __pyx_v_memviewslice.memview->view; + __pyx_v_result->__pyx_base.view = __pyx_t_5; + + /* "View.MemoryView":1024 + * + * result.view = memviewslice.memview.view + * result.view.buf = memviewslice.data # <<<<<<<<<<<<<< + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None + */ + __pyx_v_result->__pyx_base.view.buf = ((void *)__pyx_v_memviewslice.data); + + /* "View.MemoryView":1025 + * result.view = memviewslice.memview.view + * result.view.buf = memviewslice.data + * result.view.ndim = ndim # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &result.view).obj = Py_None + * Py_INCREF(Py_None) + */ + __pyx_v_result->__pyx_base.view.ndim = __pyx_v_ndim; + + /* "View.MemoryView":1026 + * result.view.buf = memviewslice.data + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * + */ + ((Py_buffer *)(&__pyx_v_result->__pyx_base.view))->obj = Py_None; + + /* "View.MemoryView":1027 + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: + */ + Py_INCREF(Py_None); + + /* "View.MemoryView":1029 + * Py_INCREF(Py_None) + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< + * result.flags = PyBUF_RECORDS + * else: + */ + __pyx_t_1 = ((((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->flags & PyBUF_WRITABLE) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1030 + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: + * result.flags = PyBUF_RECORDS # <<<<<<<<<<<<<< + * else: + * result.flags = PyBUF_RECORDS_RO + */ + __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS; + + /* "View.MemoryView":1029 + * Py_INCREF(Py_None) + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< + * result.flags = PyBUF_RECORDS + * else: + */ + goto __pyx_L4; + } + + /* "View.MemoryView":1032 + * result.flags = PyBUF_RECORDS + * else: + * result.flags = PyBUF_RECORDS_RO # <<<<<<<<<<<<<< + * + * result.view.shape = result.from_slice.shape + */ + /*else*/ { + __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS_RO; + } + __pyx_L4:; + + /* "View.MemoryView":1034 + * result.flags = PyBUF_RECORDS_RO + * + * result.view.shape = result.from_slice.shape # <<<<<<<<<<<<<< + * result.view.strides = result.from_slice.strides + * + */ + __pyx_v_result->__pyx_base.view.shape = ((Py_ssize_t *)__pyx_v_result->from_slice.shape); + + /* "View.MemoryView":1035 + * + * result.view.shape = result.from_slice.shape + * result.view.strides = result.from_slice.strides # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_result->__pyx_base.view.strides = ((Py_ssize_t *)__pyx_v_result->from_slice.strides); + + /* "View.MemoryView":1038 + * + * + * result.view.suboffsets = NULL # <<<<<<<<<<<<<< + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: + */ + __pyx_v_result->__pyx_base.view.suboffsets = NULL; + + /* "View.MemoryView":1039 + * + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: # <<<<<<<<<<<<<< + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets + */ + __pyx_t_7 = (__pyx_v_result->from_slice.suboffsets + __pyx_v_ndim); + for (__pyx_t_8 = __pyx_v_result->from_slice.suboffsets; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { + __pyx_t_6 = __pyx_t_8; + __pyx_v_suboffset = (__pyx_t_6[0]); + + /* "View.MemoryView":1040 + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * result.view.suboffsets = result.from_slice.suboffsets + * break + */ + __pyx_t_1 = ((__pyx_v_suboffset >= 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1041 + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets # <<<<<<<<<<<<<< + * break + * + */ + __pyx_v_result->__pyx_base.view.suboffsets = ((Py_ssize_t *)__pyx_v_result->from_slice.suboffsets); + + /* "View.MemoryView":1042 + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets + * break # <<<<<<<<<<<<<< + * + * result.view.len = result.view.itemsize + */ + goto __pyx_L6_break; + + /* "View.MemoryView":1040 + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * result.view.suboffsets = result.from_slice.suboffsets + * break + */ + } + } + __pyx_L6_break:; + + /* "View.MemoryView":1044 + * break + * + * result.view.len = result.view.itemsize # <<<<<<<<<<<<<< + * for length in result.view.shape[:ndim]: + * result.view.len *= length + */ + __pyx_t_9 = __pyx_v_result->__pyx_base.view.itemsize; + __pyx_v_result->__pyx_base.view.len = __pyx_t_9; + + /* "View.MemoryView":1045 + * + * result.view.len = result.view.itemsize + * for length in result.view.shape[:ndim]: # <<<<<<<<<<<<<< + * result.view.len *= length + * + */ + __pyx_t_7 = (__pyx_v_result->__pyx_base.view.shape + __pyx_v_ndim); + for (__pyx_t_8 = __pyx_v_result->__pyx_base.view.shape; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { + __pyx_t_6 = __pyx_t_8; + __pyx_t_2 = PyInt_FromSsize_t((__pyx_t_6[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":1046 + * result.view.len = result.view.itemsize + * for length in result.view.shape[:ndim]: + * result.view.len *= length # <<<<<<<<<<<<<< + * + * result.to_object_func = to_object_func + */ + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_result->__pyx_base.view.len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1046, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_t_2, __pyx_v_length); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1046, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 1046, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result->__pyx_base.view.len = __pyx_t_9; + } + + /* "View.MemoryView":1048 + * result.view.len *= length + * + * result.to_object_func = to_object_func # <<<<<<<<<<<<<< + * result.to_dtype_func = to_dtype_func + * + */ + __pyx_v_result->to_object_func = __pyx_v_to_object_func; + + /* "View.MemoryView":1049 + * + * result.to_object_func = to_object_func + * result.to_dtype_func = to_dtype_func # <<<<<<<<<<<<<< + * + * return result + */ + __pyx_v_result->to_dtype_func = __pyx_v_to_dtype_func; + + /* "View.MemoryView":1051 + * result.to_dtype_func = to_dtype_func + * + * return result # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "View.MemoryView":1001 + * + * @cname('__pyx_memoryview_fromslice') + * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< + * int ndim, + * object (*to_object_func)(char *), + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview_fromslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XDECREF(__pyx_v_length); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1054 + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') + * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + */ + +static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_mslice) { + struct __pyx_memoryviewslice_obj *__pyx_v_obj = 0; + __Pyx_memviewslice *__pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_slice_from_memview", 0); + + /* "View.MemoryView":1057 + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * obj = memview + * return &obj.from_slice + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1058 + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): + * obj = memview # <<<<<<<<<<<<<< + * return &obj.from_slice + * else: + */ + if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 1058, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_v_memview); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":1059 + * if isinstance(memview, _memoryviewslice): + * obj = memview + * return &obj.from_slice # <<<<<<<<<<<<<< + * else: + * slice_copy(memview, mslice) + */ + __pyx_r = (&__pyx_v_obj->from_slice); + goto __pyx_L0; + + /* "View.MemoryView":1057 + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * obj = memview + * return &obj.from_slice + */ + } + + /* "View.MemoryView":1061 + * return &obj.from_slice + * else: + * slice_copy(memview, mslice) # <<<<<<<<<<<<<< + * return mslice + * + */ + /*else*/ { + __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice); + + /* "View.MemoryView":1062 + * else: + * slice_copy(memview, mslice) + * return mslice # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_slice_copy') + */ + __pyx_r = __pyx_v_mslice; + goto __pyx_L0; + } + + /* "View.MemoryView":1054 + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') + * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.get_slice_from_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_obj); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1065 + * + * @cname('__pyx_memoryview_slice_copy') + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< + * cdef int dim + * cdef (Py_ssize_t*) shape, strides, suboffsets + */ + +static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_dst) { + int __pyx_v_dim; + Py_ssize_t *__pyx_v_shape; + Py_ssize_t *__pyx_v_strides; + Py_ssize_t *__pyx_v_suboffsets; + __Pyx_RefNannyDeclarations + Py_ssize_t *__pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + Py_ssize_t __pyx_t_5; + __Pyx_RefNannySetupContext("slice_copy", 0); + + /* "View.MemoryView":1069 + * cdef (Py_ssize_t*) shape, strides, suboffsets + * + * shape = memview.view.shape # <<<<<<<<<<<<<< + * strides = memview.view.strides + * suboffsets = memview.view.suboffsets + */ + __pyx_t_1 = __pyx_v_memview->view.shape; + __pyx_v_shape = __pyx_t_1; + + /* "View.MemoryView":1070 + * + * shape = memview.view.shape + * strides = memview.view.strides # <<<<<<<<<<<<<< + * suboffsets = memview.view.suboffsets + * + */ + __pyx_t_1 = __pyx_v_memview->view.strides; + __pyx_v_strides = __pyx_t_1; + + /* "View.MemoryView":1071 + * shape = memview.view.shape + * strides = memview.view.strides + * suboffsets = memview.view.suboffsets # <<<<<<<<<<<<<< + * + * dst.memview = <__pyx_memoryview *> memview + */ + __pyx_t_1 = __pyx_v_memview->view.suboffsets; + __pyx_v_suboffsets = __pyx_t_1; + + /* "View.MemoryView":1073 + * suboffsets = memview.view.suboffsets + * + * dst.memview = <__pyx_memoryview *> memview # <<<<<<<<<<<<<< + * dst.data = memview.view.buf + * + */ + __pyx_v_dst->memview = ((struct __pyx_memoryview_obj *)__pyx_v_memview); + + /* "View.MemoryView":1074 + * + * dst.memview = <__pyx_memoryview *> memview + * dst.data = memview.view.buf # <<<<<<<<<<<<<< + * + * for dim in range(memview.view.ndim): + */ + __pyx_v_dst->data = ((char *)__pyx_v_memview->view.buf); + + /* "View.MemoryView":1076 + * dst.data = memview.view.buf + * + * for dim in range(memview.view.ndim): # <<<<<<<<<<<<<< + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] + */ + __pyx_t_2 = __pyx_v_memview->view.ndim; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_dim = __pyx_t_4; + + /* "View.MemoryView":1077 + * + * for dim in range(memview.view.ndim): + * dst.shape[dim] = shape[dim] # <<<<<<<<<<<<<< + * dst.strides[dim] = strides[dim] + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 + */ + (__pyx_v_dst->shape[__pyx_v_dim]) = (__pyx_v_shape[__pyx_v_dim]); + + /* "View.MemoryView":1078 + * for dim in range(memview.view.ndim): + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] # <<<<<<<<<<<<<< + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 + * + */ + (__pyx_v_dst->strides[__pyx_v_dim]) = (__pyx_v_strides[__pyx_v_dim]); + + /* "View.MemoryView":1079 + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_object') + */ + if ((__pyx_v_suboffsets != 0)) { + __pyx_t_5 = (__pyx_v_suboffsets[__pyx_v_dim]); + } else { + __pyx_t_5 = -1L; + } + (__pyx_v_dst->suboffsets[__pyx_v_dim]) = __pyx_t_5; + } + + /* "View.MemoryView":1065 + * + * @cname('__pyx_memoryview_slice_copy') + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< + * cdef int dim + * cdef (Py_ssize_t*) shape, strides, suboffsets + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":1082 + * + * @cname('__pyx_memoryview_copy_object') + * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< + * "Create a new memoryview object" + * cdef __Pyx_memviewslice memviewslice + */ + +static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx_v_memview) { + __Pyx_memviewslice __pyx_v_memviewslice; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_copy", 0); + + /* "View.MemoryView":1085 + * "Create a new memoryview object" + * cdef __Pyx_memviewslice memviewslice + * slice_copy(memview, &memviewslice) # <<<<<<<<<<<<<< + * return memoryview_copy_from_slice(memview, &memviewslice) + * + */ + __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_memviewslice)); + + /* "View.MemoryView":1086 + * cdef __Pyx_memviewslice memviewslice + * slice_copy(memview, &memviewslice) + * return memoryview_copy_from_slice(memview, &memviewslice) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_object_from_slice') + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_memoryview_copy_object_from_slice(__pyx_v_memview, (&__pyx_v_memviewslice)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1086, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":1082 + * + * @cname('__pyx_memoryview_copy_object') + * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< + * "Create a new memoryview object" + * cdef __Pyx_memviewslice memviewslice + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview_copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1089 + * + * @cname('__pyx_memoryview_copy_object_from_slice') + * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< + * """ + * Create a new memoryview object from a given memoryview object and slice. + */ + +static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_memviewslice) { + PyObject *(*__pyx_v_to_object_func)(char *); + int (*__pyx_v_to_dtype_func)(char *, PyObject *); + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *(*__pyx_t_3)(char *); + int (*__pyx_t_4)(char *, PyObject *); + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 0); + + /* "View.MemoryView":1096 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1097 + * + * if isinstance(memview, _memoryviewslice): + * to_object_func = (<_memoryviewslice> memview).to_object_func # <<<<<<<<<<<<<< + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + * else: + */ + __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func; + __pyx_v_to_object_func = __pyx_t_3; + + /* "View.MemoryView":1098 + * if isinstance(memview, _memoryviewslice): + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func # <<<<<<<<<<<<<< + * else: + * to_object_func = NULL + */ + __pyx_t_4 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func; + __pyx_v_to_dtype_func = __pyx_t_4; + + /* "View.MemoryView":1096 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1100 + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + * else: + * to_object_func = NULL # <<<<<<<<<<<<<< + * to_dtype_func = NULL + * + */ + /*else*/ { + __pyx_v_to_object_func = NULL; + + /* "View.MemoryView":1101 + * else: + * to_object_func = NULL + * to_dtype_func = NULL # <<<<<<<<<<<<<< + * + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, + */ + __pyx_v_to_dtype_func = NULL; + } + __pyx_L3:; + + /* "View.MemoryView":1103 + * to_dtype_func = NULL + * + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, # <<<<<<<<<<<<<< + * to_object_func, to_dtype_func, + * memview.dtype_is_object) + */ + __Pyx_XDECREF(__pyx_r); + + /* "View.MemoryView":1105 + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, + * to_object_func, to_dtype_func, + * memview.dtype_is_object) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __pyx_memoryview_fromslice((__pyx_v_memviewslice[0]), __pyx_v_memview->view.ndim, __pyx_v_to_object_func, __pyx_v_to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "View.MemoryView":1089 + * + * @cname('__pyx_memoryview_copy_object_from_slice') + * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< + * """ + * Create a new memoryview object from a given memoryview object and slice. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview_copy_from_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1111 + * + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< + * if arg < 0: + * return -arg + */ + +static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { + Py_ssize_t __pyx_r; + int __pyx_t_1; + + /* "View.MemoryView":1112 + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: # <<<<<<<<<<<<<< + * return -arg + * else: + */ + __pyx_t_1 = ((__pyx_v_arg < 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1113 + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: + * return -arg # <<<<<<<<<<<<<< + * else: + * return arg + */ + __pyx_r = (-__pyx_v_arg); + goto __pyx_L0; + + /* "View.MemoryView":1112 + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: # <<<<<<<<<<<<<< + * return -arg + * else: + */ + } + + /* "View.MemoryView":1115 + * return -arg + * else: + * return arg # <<<<<<<<<<<<<< + * + * @cname('__pyx_get_best_slice_order') + */ + /*else*/ { + __pyx_r = __pyx_v_arg; + goto __pyx_L0; + } + + /* "View.MemoryView":1111 + * + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< + * if arg < 0: + * return -arg + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1118 + * + * @cname('__pyx_get_best_slice_order') + * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< + * """ + * Figure out the best memory access order for a given slice. + */ + +static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim) { + int __pyx_v_i; + Py_ssize_t __pyx_v_c_stride; + Py_ssize_t __pyx_v_f_stride; + char __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + + /* "View.MemoryView":1123 + * """ + * cdef int i + * cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<< + * cdef Py_ssize_t f_stride = 0 + * + */ + __pyx_v_c_stride = 0; + + /* "View.MemoryView":1124 + * cdef int i + * cdef Py_ssize_t c_stride = 0 + * cdef Py_ssize_t f_stride = 0 # <<<<<<<<<<<<<< + * + * for i in range(ndim - 1, -1, -1): + */ + __pyx_v_f_stride = 0; + + /* "View.MemoryView":1126 + * cdef Py_ssize_t f_stride = 0 + * + * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] + */ + for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { + __pyx_v_i = __pyx_t_1; + + /* "View.MemoryView":1127 + * + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * c_stride = mslice.strides[i] + * break + */ + __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1128 + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] # <<<<<<<<<<<<<< + * break + * + */ + __pyx_v_c_stride = (__pyx_v_mslice->strides[__pyx_v_i]); + + /* "View.MemoryView":1129 + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] + * break # <<<<<<<<<<<<<< + * + * for i in range(ndim): + */ + goto __pyx_L4_break; + + /* "View.MemoryView":1127 + * + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * c_stride = mslice.strides[i] + * break + */ + } + } + __pyx_L4_break:; + + /* "View.MemoryView":1131 + * break + * + * for i in range(ndim): # <<<<<<<<<<<<<< + * if mslice.shape[i] > 1: + * f_stride = mslice.strides[i] + */ + __pyx_t_1 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_1; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1132 + * + * for i in range(ndim): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * f_stride = mslice.strides[i] + * break + */ + __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1133 + * for i in range(ndim): + * if mslice.shape[i] > 1: + * f_stride = mslice.strides[i] # <<<<<<<<<<<<<< + * break + * + */ + __pyx_v_f_stride = (__pyx_v_mslice->strides[__pyx_v_i]); + + /* "View.MemoryView":1134 + * if mslice.shape[i] > 1: + * f_stride = mslice.strides[i] + * break # <<<<<<<<<<<<<< + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): + */ + goto __pyx_L7_break; + + /* "View.MemoryView":1132 + * + * for i in range(ndim): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * f_stride = mslice.strides[i] + * break + */ + } + } + __pyx_L7_break:; + + /* "View.MemoryView":1136 + * break + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< + * return 'C' + * else: + */ + __pyx_t_2 = ((abs_py_ssize_t(__pyx_v_c_stride) <= abs_py_ssize_t(__pyx_v_f_stride)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1137 + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): + * return 'C' # <<<<<<<<<<<<<< + * else: + * return 'F' + */ + __pyx_r = 'C'; + goto __pyx_L0; + + /* "View.MemoryView":1136 + * break + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< + * return 'C' + * else: + */ + } + + /* "View.MemoryView":1139 + * return 'C' + * else: + * return 'F' # <<<<<<<<<<<<<< + * + * @cython.cdivision(True) + */ + /*else*/ { + __pyx_r = 'F'; + goto __pyx_L0; + } + + /* "View.MemoryView":1118 + * + * @cname('__pyx_get_best_slice_order') + * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< + * """ + * Figure out the best memory access order for a given slice. + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1142 + * + * @cython.cdivision(True) + * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< + * char *dst_data, Py_ssize_t *dst_strides, + * Py_ssize_t *src_shape, Py_ssize_t *dst_shape, + */ + +static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v_src_strides, char *__pyx_v_dst_data, Py_ssize_t *__pyx_v_dst_strides, Py_ssize_t *__pyx_v_src_shape, Py_ssize_t *__pyx_v_dst_shape, int __pyx_v_ndim, size_t __pyx_v_itemsize) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + CYTHON_UNUSED Py_ssize_t __pyx_v_src_extent; + Py_ssize_t __pyx_v_dst_extent; + Py_ssize_t __pyx_v_src_stride; + Py_ssize_t __pyx_v_dst_stride; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + Py_ssize_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + Py_ssize_t __pyx_t_6; + + /* "View.MemoryView":1149 + * + * cdef Py_ssize_t i + * cdef Py_ssize_t src_extent = src_shape[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t dst_extent = dst_shape[0] + * cdef Py_ssize_t src_stride = src_strides[0] + */ + __pyx_v_src_extent = (__pyx_v_src_shape[0]); + + /* "View.MemoryView":1150 + * cdef Py_ssize_t i + * cdef Py_ssize_t src_extent = src_shape[0] + * cdef Py_ssize_t dst_extent = dst_shape[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t src_stride = src_strides[0] + * cdef Py_ssize_t dst_stride = dst_strides[0] + */ + __pyx_v_dst_extent = (__pyx_v_dst_shape[0]); + + /* "View.MemoryView":1151 + * cdef Py_ssize_t src_extent = src_shape[0] + * cdef Py_ssize_t dst_extent = dst_shape[0] + * cdef Py_ssize_t src_stride = src_strides[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t dst_stride = dst_strides[0] + * + */ + __pyx_v_src_stride = (__pyx_v_src_strides[0]); + + /* "View.MemoryView":1152 + * cdef Py_ssize_t dst_extent = dst_shape[0] + * cdef Py_ssize_t src_stride = src_strides[0] + * cdef Py_ssize_t dst_stride = dst_strides[0] # <<<<<<<<<<<<<< + * + * if ndim == 1: + */ + __pyx_v_dst_stride = (__pyx_v_dst_strides[0]); + + /* "View.MemoryView":1154 + * cdef Py_ssize_t dst_stride = dst_strides[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): + */ + __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1155 + * + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) + */ + __pyx_t_2 = ((__pyx_v_src_stride > 0) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L5_bool_binop_done; + } + __pyx_t_2 = ((__pyx_v_dst_stride > 0) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L5_bool_binop_done; + } + + /* "View.MemoryView":1156 + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): # <<<<<<<<<<<<<< + * memcpy(dst_data, src_data, itemsize * dst_extent) + * else: + */ + __pyx_t_2 = (((size_t)__pyx_v_src_stride) == __pyx_v_itemsize); + if (__pyx_t_2) { + __pyx_t_2 = (__pyx_v_itemsize == ((size_t)__pyx_v_dst_stride)); + } + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L5_bool_binop_done:; + + /* "View.MemoryView":1155 + * + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) + */ + if (__pyx_t_1) { + + /* "View.MemoryView":1157 + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) # <<<<<<<<<<<<<< + * else: + * for i in range(dst_extent): + */ + (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, (__pyx_v_itemsize * __pyx_v_dst_extent))); + + /* "View.MemoryView":1155 + * + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) + */ + goto __pyx_L4; + } + + /* "View.MemoryView":1159 + * memcpy(dst_data, src_data, itemsize * dst_extent) + * else: + * for i in range(dst_extent): # <<<<<<<<<<<<<< + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride + */ + /*else*/ { + __pyx_t_4 = __pyx_v_dst_extent; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1160 + * else: + * for i in range(dst_extent): + * memcpy(dst_data, src_data, itemsize) # <<<<<<<<<<<<<< + * src_data += src_stride + * dst_data += dst_stride + */ + (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, __pyx_v_itemsize)); + + /* "View.MemoryView":1161 + * for i in range(dst_extent): + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride # <<<<<<<<<<<<<< + * dst_data += dst_stride + * else: + */ + __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); + + /* "View.MemoryView":1162 + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride + * dst_data += dst_stride # <<<<<<<<<<<<<< + * else: + * for i in range(dst_extent): + */ + __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); + } + } + __pyx_L4:; + + /* "View.MemoryView":1154 + * cdef Py_ssize_t dst_stride = dst_strides[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1164 + * dst_data += dst_stride + * else: + * for i in range(dst_extent): # <<<<<<<<<<<<<< + * _copy_strided_to_strided(src_data, src_strides + 1, + * dst_data, dst_strides + 1, + */ + /*else*/ { + __pyx_t_4 = __pyx_v_dst_extent; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1165 + * else: + * for i in range(dst_extent): + * _copy_strided_to_strided(src_data, src_strides + 1, # <<<<<<<<<<<<<< + * dst_data, dst_strides + 1, + * src_shape + 1, dst_shape + 1, + */ + _copy_strided_to_strided(__pyx_v_src_data, (__pyx_v_src_strides + 1), __pyx_v_dst_data, (__pyx_v_dst_strides + 1), (__pyx_v_src_shape + 1), (__pyx_v_dst_shape + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize); + + /* "View.MemoryView":1169 + * src_shape + 1, dst_shape + 1, + * ndim - 1, itemsize) + * src_data += src_stride # <<<<<<<<<<<<<< + * dst_data += dst_stride + * + */ + __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); + + /* "View.MemoryView":1170 + * ndim - 1, itemsize) + * src_data += src_stride + * dst_data += dst_stride # <<<<<<<<<<<<<< + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, + */ + __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); + } + } + __pyx_L3:; + + /* "View.MemoryView":1142 + * + * @cython.cdivision(True) + * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< + * char *dst_data, Py_ssize_t *dst_strides, + * Py_ssize_t *src_shape, Py_ssize_t *dst_shape, + */ + + /* function exit code */ +} + +/* "View.MemoryView":1172 + * dst_data += dst_stride + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) nogil: + */ + +static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize) { + + /* "View.MemoryView":1175 + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) nogil: + * _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides, # <<<<<<<<<<<<<< + * src.shape, dst.shape, ndim, itemsize) + * + */ + _copy_strided_to_strided(__pyx_v_src->data, __pyx_v_src->strides, __pyx_v_dst->data, __pyx_v_dst->strides, __pyx_v_src->shape, __pyx_v_dst->shape, __pyx_v_ndim, __pyx_v_itemsize); + + /* "View.MemoryView":1172 + * dst_data += dst_stride + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1179 + * + * @cname('__pyx_memoryview_slice_get_size') + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< + * "Return the size of the memory occupied by the slice in number of bytes" + * cdef Py_ssize_t shape, size = src.memview.view.itemsize + */ + +static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_src, int __pyx_v_ndim) { + Py_ssize_t __pyx_v_shape; + Py_ssize_t __pyx_v_size; + Py_ssize_t __pyx_r; + Py_ssize_t __pyx_t_1; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + + /* "View.MemoryView":1181 + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: + * "Return the size of the memory occupied by the slice in number of bytes" + * cdef Py_ssize_t shape, size = src.memview.view.itemsize # <<<<<<<<<<<<<< + * + * for shape in src.shape[:ndim]: + */ + __pyx_t_1 = __pyx_v_src->memview->view.itemsize; + __pyx_v_size = __pyx_t_1; + + /* "View.MemoryView":1183 + * cdef Py_ssize_t shape, size = src.memview.view.itemsize + * + * for shape in src.shape[:ndim]: # <<<<<<<<<<<<<< + * size *= shape + * + */ + __pyx_t_3 = (__pyx_v_src->shape + __pyx_v_ndim); + for (__pyx_t_4 = __pyx_v_src->shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { + __pyx_t_2 = __pyx_t_4; + __pyx_v_shape = (__pyx_t_2[0]); + + /* "View.MemoryView":1184 + * + * for shape in src.shape[:ndim]: + * size *= shape # <<<<<<<<<<<<<< + * + * return size + */ + __pyx_v_size = (__pyx_v_size * __pyx_v_shape); + } + + /* "View.MemoryView":1186 + * size *= shape + * + * return size # <<<<<<<<<<<<<< + * + * @cname('__pyx_fill_contig_strides_array') + */ + __pyx_r = __pyx_v_size; + goto __pyx_L0; + + /* "View.MemoryView":1179 + * + * @cname('__pyx_memoryview_slice_get_size') + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< + * "Return the size of the memory occupied by the slice in number of bytes" + * cdef Py_ssize_t shape, size = src.memview.view.itemsize + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1189 + * + * @cname('__pyx_fill_contig_strides_array') + * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< + * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, + * int ndim, char order) nogil: + */ + +static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, Py_ssize_t __pyx_v_stride, int __pyx_v_ndim, char __pyx_v_order) { + int __pyx_v_idx; + Py_ssize_t __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + + /* "View.MemoryView":1198 + * cdef int idx + * + * if order == 'F': # <<<<<<<<<<<<<< + * for idx in range(ndim): + * strides[idx] = stride + */ + __pyx_t_1 = ((__pyx_v_order == 'F') != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1199 + * + * if order == 'F': + * for idx in range(ndim): # <<<<<<<<<<<<<< + * strides[idx] = stride + * stride *= shape[idx] + */ + __pyx_t_2 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_idx = __pyx_t_4; + + /* "View.MemoryView":1200 + * if order == 'F': + * for idx in range(ndim): + * strides[idx] = stride # <<<<<<<<<<<<<< + * stride *= shape[idx] + * else: + */ + (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; + + /* "View.MemoryView":1201 + * for idx in range(ndim): + * strides[idx] = stride + * stride *= shape[idx] # <<<<<<<<<<<<<< + * else: + * for idx in range(ndim - 1, -1, -1): + */ + __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); + } + + /* "View.MemoryView":1198 + * cdef int idx + * + * if order == 'F': # <<<<<<<<<<<<<< + * for idx in range(ndim): + * strides[idx] = stride + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1203 + * stride *= shape[idx] + * else: + * for idx in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< + * strides[idx] = stride + * stride *= shape[idx] + */ + /*else*/ { + for (__pyx_t_2 = (__pyx_v_ndim - 1); __pyx_t_2 > -1; __pyx_t_2-=1) { + __pyx_v_idx = __pyx_t_2; + + /* "View.MemoryView":1204 + * else: + * for idx in range(ndim - 1, -1, -1): + * strides[idx] = stride # <<<<<<<<<<<<<< + * stride *= shape[idx] + * + */ + (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; + + /* "View.MemoryView":1205 + * for idx in range(ndim - 1, -1, -1): + * strides[idx] = stride + * stride *= shape[idx] # <<<<<<<<<<<<<< + * + * return stride + */ + __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); + } + } + __pyx_L3:; + + /* "View.MemoryView":1207 + * stride *= shape[idx] + * + * return stride # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_data_to_temp') + */ + __pyx_r = __pyx_v_stride; + goto __pyx_L0; + + /* "View.MemoryView":1189 + * + * @cname('__pyx_fill_contig_strides_array') + * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< + * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, + * int ndim, char order) nogil: + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1210 + * + * @cname('__pyx_memoryview_copy_data_to_temp') + * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *tmpslice, + * char order, + */ + +static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_tmpslice, char __pyx_v_order, int __pyx_v_ndim) { + int __pyx_v_i; + void *__pyx_v_result; + size_t __pyx_v_itemsize; + size_t __pyx_v_size; + void *__pyx_r; + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + struct __pyx_memoryview_obj *__pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":1221 + * cdef void *result + * + * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< + * cdef size_t size = slice_get_size(src, ndim) + * + */ + __pyx_t_1 = __pyx_v_src->memview->view.itemsize; + __pyx_v_itemsize = __pyx_t_1; + + /* "View.MemoryView":1222 + * + * cdef size_t itemsize = src.memview.view.itemsize + * cdef size_t size = slice_get_size(src, ndim) # <<<<<<<<<<<<<< + * + * result = malloc(size) + */ + __pyx_v_size = __pyx_memoryview_slice_get_size(__pyx_v_src, __pyx_v_ndim); + + /* "View.MemoryView":1224 + * cdef size_t size = slice_get_size(src, ndim) + * + * result = malloc(size) # <<<<<<<<<<<<<< + * if not result: + * _err(MemoryError, NULL) + */ + __pyx_v_result = malloc(__pyx_v_size); + + /* "View.MemoryView":1225 + * + * result = malloc(size) + * if not result: # <<<<<<<<<<<<<< + * _err(MemoryError, NULL) + * + */ + __pyx_t_2 = ((!(__pyx_v_result != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1226 + * result = malloc(size) + * if not result: + * _err(MemoryError, NULL) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_memoryview_err(__pyx_builtin_MemoryError, NULL); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 1226, __pyx_L1_error) + + /* "View.MemoryView":1225 + * + * result = malloc(size) + * if not result: # <<<<<<<<<<<<<< + * _err(MemoryError, NULL) + * + */ + } + + /* "View.MemoryView":1229 + * + * + * tmpslice.data = result # <<<<<<<<<<<<<< + * tmpslice.memview = src.memview + * for i in range(ndim): + */ + __pyx_v_tmpslice->data = ((char *)__pyx_v_result); + + /* "View.MemoryView":1230 + * + * tmpslice.data = result + * tmpslice.memview = src.memview # <<<<<<<<<<<<<< + * for i in range(ndim): + * tmpslice.shape[i] = src.shape[i] + */ + __pyx_t_4 = __pyx_v_src->memview; + __pyx_v_tmpslice->memview = __pyx_t_4; + + /* "View.MemoryView":1231 + * tmpslice.data = result + * tmpslice.memview = src.memview + * for i in range(ndim): # <<<<<<<<<<<<<< + * tmpslice.shape[i] = src.shape[i] + * tmpslice.suboffsets[i] = -1 + */ + __pyx_t_3 = __pyx_v_ndim; + __pyx_t_5 = __pyx_t_3; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1232 + * tmpslice.memview = src.memview + * for i in range(ndim): + * tmpslice.shape[i] = src.shape[i] # <<<<<<<<<<<<<< + * tmpslice.suboffsets[i] = -1 + * + */ + (__pyx_v_tmpslice->shape[__pyx_v_i]) = (__pyx_v_src->shape[__pyx_v_i]); + + /* "View.MemoryView":1233 + * for i in range(ndim): + * tmpslice.shape[i] = src.shape[i] + * tmpslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< + * + * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, + */ + (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L; + } + + /* "View.MemoryView":1235 + * tmpslice.suboffsets[i] = -1 + * + * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, # <<<<<<<<<<<<<< + * ndim, order) + * + */ + (void)(__pyx_fill_contig_strides_array((&(__pyx_v_tmpslice->shape[0])), (&(__pyx_v_tmpslice->strides[0])), __pyx_v_itemsize, __pyx_v_ndim, __pyx_v_order)); + + /* "View.MemoryView":1239 + * + * + * for i in range(ndim): # <<<<<<<<<<<<<< + * if tmpslice.shape[i] == 1: + * tmpslice.strides[i] = 0 + */ + __pyx_t_3 = __pyx_v_ndim; + __pyx_t_5 = __pyx_t_3; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1240 + * + * for i in range(ndim): + * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< + * tmpslice.strides[i] = 0 + * + */ + __pyx_t_2 = (((__pyx_v_tmpslice->shape[__pyx_v_i]) == 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1241 + * for i in range(ndim): + * if tmpslice.shape[i] == 1: + * tmpslice.strides[i] = 0 # <<<<<<<<<<<<<< + * + * if slice_is_contig(src[0], order, ndim): + */ + (__pyx_v_tmpslice->strides[__pyx_v_i]) = 0; + + /* "View.MemoryView":1240 + * + * for i in range(ndim): + * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< + * tmpslice.strides[i] = 0 + * + */ + } + } + + /* "View.MemoryView":1243 + * tmpslice.strides[i] = 0 + * + * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< + * memcpy(result, src.data, size) + * else: + */ + __pyx_t_2 = (__pyx_memviewslice_is_contig((__pyx_v_src[0]), __pyx_v_order, __pyx_v_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1244 + * + * if slice_is_contig(src[0], order, ndim): + * memcpy(result, src.data, size) # <<<<<<<<<<<<<< + * else: + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) + */ + (void)(memcpy(__pyx_v_result, __pyx_v_src->data, __pyx_v_size)); + + /* "View.MemoryView":1243 + * tmpslice.strides[i] = 0 + * + * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< + * memcpy(result, src.data, size) + * else: + */ + goto __pyx_L9; + } + + /* "View.MemoryView":1246 + * memcpy(result, src.data, size) + * else: + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) # <<<<<<<<<<<<<< + * + * return result + */ + /*else*/ { + copy_strided_to_strided(__pyx_v_src, __pyx_v_tmpslice, __pyx_v_ndim, __pyx_v_itemsize); + } + __pyx_L9:; + + /* "View.MemoryView":1248 + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) + * + * return result # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "View.MemoryView":1210 + * + * @cname('__pyx_memoryview_copy_data_to_temp') + * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *tmpslice, + * char order, + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.copy_data_to_temp", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = NULL; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1253 + * + * @cname('__pyx_memoryview_err_extents') + * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % + */ + +static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent1, Py_ssize_t __pyx_v_extent2) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("_err_extents", 0); + + /* "View.MemoryView":1256 + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % + * (i, extent1, extent2)) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_err_dim') + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_extent1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_extent2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + + /* "View.MemoryView":1255 + * cdef int _err_extents(int i, Py_ssize_t extent1, + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % # <<<<<<<<<<<<<< + * (i, extent1, extent2)) + * + */ + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 1255, __pyx_L1_error) + + /* "View.MemoryView":1253 + * + * @cname('__pyx_memoryview_err_extents') + * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView._err_extents", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "View.MemoryView":1259 + * + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii') % dim) + * + */ + +static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, int __pyx_v_dim) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("_err_dim", 0); + __Pyx_INCREF(__pyx_v_error); + + /* "View.MemoryView":1260 + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: + * raise error(msg.decode('ascii') % dim) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_err') + */ + __pyx_t_2 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyUnicode_Format(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_INCREF(__pyx_v_error); + __pyx_t_3 = __pyx_v_error; __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 1260, __pyx_L1_error) + + /* "View.MemoryView":1259 + * + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii') % dim) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView._err_dim", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_XDECREF(__pyx_v_error); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "View.MemoryView":1263 + * + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< + * if msg != NULL: + * raise error(msg.decode('ascii')) + */ + +static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("_err", 0); + __Pyx_INCREF(__pyx_v_error); + + /* "View.MemoryView":1264 + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: + * if msg != NULL: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii')) + * else: + */ + __pyx_t_1 = ((__pyx_v_msg != NULL) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":1265 + * cdef int _err(object error, char *msg) except -1 with gil: + * if msg != NULL: + * raise error(msg.decode('ascii')) # <<<<<<<<<<<<<< + * else: + * raise error + */ + __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_error); + __pyx_t_4 = __pyx_v_error; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 1265, __pyx_L1_error) + + /* "View.MemoryView":1264 + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: + * if msg != NULL: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii')) + * else: + */ + } + + /* "View.MemoryView":1267 + * raise error(msg.decode('ascii')) + * else: + * raise error # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_contents') + */ + /*else*/ { + __Pyx_Raise(__pyx_v_error, 0, 0, 0); + __PYX_ERR(1, 1267, __pyx_L1_error) + } + + /* "View.MemoryView":1263 + * + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< + * if msg != NULL: + * raise error(msg.decode('ascii')) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView._err", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_XDECREF(__pyx_v_error); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "View.MemoryView":1270 + * + * @cname('__pyx_memoryview_copy_contents') + * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice dst, + * int src_ndim, int dst_ndim, + */ + +static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_memviewslice __pyx_v_dst, int __pyx_v_src_ndim, int __pyx_v_dst_ndim, int __pyx_v_dtype_is_object) { + void *__pyx_v_tmpdata; + size_t __pyx_v_itemsize; + int __pyx_v_i; + char __pyx_v_order; + int __pyx_v_broadcasting; + int __pyx_v_direct_copy; + __Pyx_memviewslice __pyx_v_tmp; + int __pyx_v_ndim; + int __pyx_r; + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + void *__pyx_t_7; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":1278 + * Check for overlapping memory and verify the shapes. + * """ + * cdef void *tmpdata = NULL # <<<<<<<<<<<<<< + * cdef size_t itemsize = src.memview.view.itemsize + * cdef int i + */ + __pyx_v_tmpdata = NULL; + + /* "View.MemoryView":1279 + * """ + * cdef void *tmpdata = NULL + * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) + */ + __pyx_t_1 = __pyx_v_src.memview->view.itemsize; + __pyx_v_itemsize = __pyx_t_1; + + /* "View.MemoryView":1281 + * cdef size_t itemsize = src.memview.view.itemsize + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) # <<<<<<<<<<<<<< + * cdef bint broadcasting = False + * cdef bint direct_copy = False + */ + __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_src), __pyx_v_src_ndim); + + /* "View.MemoryView":1282 + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) + * cdef bint broadcasting = False # <<<<<<<<<<<<<< + * cdef bint direct_copy = False + * cdef __Pyx_memviewslice tmp + */ + __pyx_v_broadcasting = 0; + + /* "View.MemoryView":1283 + * cdef char order = get_best_order(&src, src_ndim) + * cdef bint broadcasting = False + * cdef bint direct_copy = False # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice tmp + * + */ + __pyx_v_direct_copy = 0; + + /* "View.MemoryView":1286 + * cdef __Pyx_memviewslice tmp + * + * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: + */ + __pyx_t_2 = ((__pyx_v_src_ndim < __pyx_v_dst_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1287 + * + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) # <<<<<<<<<<<<<< + * elif dst_ndim < src_ndim: + * broadcast_leading(&dst, dst_ndim, src_ndim) + */ + __pyx_memoryview_broadcast_leading((&__pyx_v_src), __pyx_v_src_ndim, __pyx_v_dst_ndim); + + /* "View.MemoryView":1286 + * cdef __Pyx_memviewslice tmp + * + * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1288 + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&dst, dst_ndim, src_ndim) + * + */ + __pyx_t_2 = ((__pyx_v_dst_ndim < __pyx_v_src_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1289 + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: + * broadcast_leading(&dst, dst_ndim, src_ndim) # <<<<<<<<<<<<<< + * + * cdef int ndim = max(src_ndim, dst_ndim) + */ + __pyx_memoryview_broadcast_leading((&__pyx_v_dst), __pyx_v_dst_ndim, __pyx_v_src_ndim); + + /* "View.MemoryView":1288 + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&dst, dst_ndim, src_ndim) + * + */ + } + __pyx_L3:; + + /* "View.MemoryView":1291 + * broadcast_leading(&dst, dst_ndim, src_ndim) + * + * cdef int ndim = max(src_ndim, dst_ndim) # <<<<<<<<<<<<<< + * + * for i in range(ndim): + */ + __pyx_t_3 = __pyx_v_dst_ndim; + __pyx_t_4 = __pyx_v_src_ndim; + if (((__pyx_t_3 > __pyx_t_4) != 0)) { + __pyx_t_5 = __pyx_t_3; + } else { + __pyx_t_5 = __pyx_t_4; + } + __pyx_v_ndim = __pyx_t_5; + + /* "View.MemoryView":1293 + * cdef int ndim = max(src_ndim, dst_ndim) + * + * for i in range(ndim): # <<<<<<<<<<<<<< + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: + */ + __pyx_t_5 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_5; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1294 + * + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< + * if src.shape[i] == 1: + * broadcasting = True + */ + __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) != (__pyx_v_dst.shape[__pyx_v_i])) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1295 + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: # <<<<<<<<<<<<<< + * broadcasting = True + * src.strides[i] = 0 + */ + __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) == 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1296 + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: + * broadcasting = True # <<<<<<<<<<<<<< + * src.strides[i] = 0 + * else: + */ + __pyx_v_broadcasting = 1; + + /* "View.MemoryView":1297 + * if src.shape[i] == 1: + * broadcasting = True + * src.strides[i] = 0 # <<<<<<<<<<<<<< + * else: + * _err_extents(i, dst.shape[i], src.shape[i]) + */ + (__pyx_v_src.strides[__pyx_v_i]) = 0; + + /* "View.MemoryView":1295 + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: # <<<<<<<<<<<<<< + * broadcasting = True + * src.strides[i] = 0 + */ + goto __pyx_L7; + } + + /* "View.MemoryView":1299 + * src.strides[i] = 0 + * else: + * _err_extents(i, dst.shape[i], src.shape[i]) # <<<<<<<<<<<<<< + * + * if src.suboffsets[i] >= 0: + */ + /*else*/ { + __pyx_t_6 = __pyx_memoryview_err_extents(__pyx_v_i, (__pyx_v_dst.shape[__pyx_v_i]), (__pyx_v_src.shape[__pyx_v_i])); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1299, __pyx_L1_error) + } + __pyx_L7:; + + /* "View.MemoryView":1294 + * + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< + * if src.shape[i] == 1: + * broadcasting = True + */ + } + + /* "View.MemoryView":1301 + * _err_extents(i, dst.shape[i], src.shape[i]) + * + * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + */ + __pyx_t_2 = (((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1302 + * + * if src.suboffsets[i] >= 0: + * _err_dim(ValueError, "Dimension %d is not direct", i) # <<<<<<<<<<<<<< + * + * if slices_overlap(&src, &dst, ndim, itemsize): + */ + __pyx_t_6 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Dimension %d is not direct"), __pyx_v_i); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1302, __pyx_L1_error) + + /* "View.MemoryView":1301 + * _err_extents(i, dst.shape[i], src.shape[i]) + * + * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + */ + } + } + + /* "View.MemoryView":1304 + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< + * + * if not slice_is_contig(src, order, ndim): + */ + __pyx_t_2 = (__pyx_slices_overlap((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1306 + * if slices_overlap(&src, &dst, ndim, itemsize): + * + * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< + * order = get_best_order(&dst, ndim) + * + */ + __pyx_t_2 = ((!(__pyx_memviewslice_is_contig(__pyx_v_src, __pyx_v_order, __pyx_v_ndim) != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1307 + * + * if not slice_is_contig(src, order, ndim): + * order = get_best_order(&dst, ndim) # <<<<<<<<<<<<<< + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) + */ + __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim); + + /* "View.MemoryView":1306 + * if slices_overlap(&src, &dst, ndim, itemsize): + * + * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< + * order = get_best_order(&dst, ndim) + * + */ + } + + /* "View.MemoryView":1309 + * order = get_best_order(&dst, ndim) + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) # <<<<<<<<<<<<<< + * src = tmp + * + */ + __pyx_t_7 = __pyx_memoryview_copy_data_to_temp((&__pyx_v_src), (&__pyx_v_tmp), __pyx_v_order, __pyx_v_ndim); if (unlikely(__pyx_t_7 == ((void *)NULL))) __PYX_ERR(1, 1309, __pyx_L1_error) + __pyx_v_tmpdata = __pyx_t_7; + + /* "View.MemoryView":1310 + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) + * src = tmp # <<<<<<<<<<<<<< + * + * if not broadcasting: + */ + __pyx_v_src = __pyx_v_tmp; + + /* "View.MemoryView":1304 + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< + * + * if not slice_is_contig(src, order, ndim): + */ + } + + /* "View.MemoryView":1312 + * src = tmp + * + * if not broadcasting: # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = ((!(__pyx_v_broadcasting != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1315 + * + * + * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): + */ + __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'C', __pyx_v_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1316 + * + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) # <<<<<<<<<<<<<< + * elif slice_is_contig(src, 'F', ndim): + * direct_copy = slice_is_contig(dst, 'F', ndim) + */ + __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'C', __pyx_v_ndim); + + /* "View.MemoryView":1315 + * + * + * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): + */ + goto __pyx_L12; + } + + /* "View.MemoryView":1317 + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + */ + __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'F', __pyx_v_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1318 + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): + * direct_copy = slice_is_contig(dst, 'F', ndim) # <<<<<<<<<<<<<< + * + * if direct_copy: + */ + __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'F', __pyx_v_ndim); + + /* "View.MemoryView":1317 + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + */ + } + __pyx_L12:; + + /* "View.MemoryView":1320 + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + * if direct_copy: # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + __pyx_t_2 = (__pyx_v_direct_copy != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1322 + * if direct_copy: + * + * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1323 + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, True) + * free(tmpdata) + */ + (void)(memcpy(__pyx_v_dst.data, __pyx_v_src.data, __pyx_memoryview_slice_get_size((&__pyx_v_src), __pyx_v_ndim))); + + /* "View.MemoryView":1324 + * refcount_copying(&dst, dtype_is_object, ndim, False) + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * free(tmpdata) + * return 0 + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1325 + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) + * free(tmpdata) # <<<<<<<<<<<<<< + * return 0 + * + */ + free(__pyx_v_tmpdata); + + /* "View.MemoryView":1326 + * refcount_copying(&dst, dtype_is_object, ndim, True) + * free(tmpdata) + * return 0 # <<<<<<<<<<<<<< + * + * if order == 'F' == get_best_order(&dst, ndim): + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":1320 + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + * if direct_copy: # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + } + + /* "View.MemoryView":1312 + * src = tmp + * + * if not broadcasting: # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":1328 + * return 0 + * + * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = (__pyx_v_order == 'F'); + if (__pyx_t_2) { + __pyx_t_2 = ('F' == __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim)); + } + __pyx_t_8 = (__pyx_t_2 != 0); + if (__pyx_t_8) { + + /* "View.MemoryView":1331 + * + * + * transpose_memslice(&src) # <<<<<<<<<<<<<< + * transpose_memslice(&dst) + * + */ + __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_src)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1331, __pyx_L1_error) + + /* "View.MemoryView":1332 + * + * transpose_memslice(&src) + * transpose_memslice(&dst) # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_dst)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1332, __pyx_L1_error) + + /* "View.MemoryView":1328 + * return 0 + * + * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":1334 + * transpose_memslice(&dst) + * + * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * copy_strided_to_strided(&src, &dst, ndim, itemsize) + * refcount_copying(&dst, dtype_is_object, ndim, True) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1335 + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + * copy_strided_to_strided(&src, &dst, ndim, itemsize) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, True) + * + */ + copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); + + /* "View.MemoryView":1336 + * refcount_copying(&dst, dtype_is_object, ndim, False) + * copy_strided_to_strided(&src, &dst, ndim, itemsize) + * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * + * free(tmpdata) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1338 + * refcount_copying(&dst, dtype_is_object, ndim, True) + * + * free(tmpdata) # <<<<<<<<<<<<<< + * return 0 + * + */ + free(__pyx_v_tmpdata); + + /* "View.MemoryView":1339 + * + * free(tmpdata) + * return 0 # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_broadcast_leading') + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":1270 + * + * @cname('__pyx_memoryview_copy_contents') + * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice dst, + * int src_ndim, int dst_ndim, + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.memoryview_copy_contents", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1342 + * + * @cname('__pyx_memoryview_broadcast_leading') + * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< + * int ndim, + * int ndim_other) nogil: + */ + +static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim, int __pyx_v_ndim_other) { + int __pyx_v_i; + int __pyx_v_offset; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + + /* "View.MemoryView":1346 + * int ndim_other) nogil: + * cdef int i + * cdef int offset = ndim_other - ndim # <<<<<<<<<<<<<< + * + * for i in range(ndim - 1, -1, -1): + */ + __pyx_v_offset = (__pyx_v_ndim_other - __pyx_v_ndim); + + /* "View.MemoryView":1348 + * cdef int offset = ndim_other - ndim + * + * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = mslice.strides[i] + */ + for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { + __pyx_v_i = __pyx_t_1; + + /* "View.MemoryView":1349 + * + * for i in range(ndim - 1, -1, -1): + * mslice.shape[i + offset] = mslice.shape[i] # <<<<<<<<<<<<<< + * mslice.strides[i + offset] = mslice.strides[i] + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] + */ + (__pyx_v_mslice->shape[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->shape[__pyx_v_i]); + + /* "View.MemoryView":1350 + * for i in range(ndim - 1, -1, -1): + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = mslice.strides[i] # <<<<<<<<<<<<<< + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] + * + */ + (__pyx_v_mslice->strides[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->strides[__pyx_v_i]); + + /* "View.MemoryView":1351 + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = mslice.strides[i] + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] # <<<<<<<<<<<<<< + * + * for i in range(offset): + */ + (__pyx_v_mslice->suboffsets[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->suboffsets[__pyx_v_i]); + } + + /* "View.MemoryView":1353 + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] + * + * for i in range(offset): # <<<<<<<<<<<<<< + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] + */ + __pyx_t_1 = __pyx_v_offset; + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_i = __pyx_t_3; + + /* "View.MemoryView":1354 + * + * for i in range(offset): + * mslice.shape[i] = 1 # <<<<<<<<<<<<<< + * mslice.strides[i] = mslice.strides[0] + * mslice.suboffsets[i] = -1 + */ + (__pyx_v_mslice->shape[__pyx_v_i]) = 1; + + /* "View.MemoryView":1355 + * for i in range(offset): + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] # <<<<<<<<<<<<<< + * mslice.suboffsets[i] = -1 + * + */ + (__pyx_v_mslice->strides[__pyx_v_i]) = (__pyx_v_mslice->strides[0]); + + /* "View.MemoryView":1356 + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] + * mslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< + * + * + */ + (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L; + } + + /* "View.MemoryView":1342 + * + * @cname('__pyx_memoryview_broadcast_leading') + * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< + * int ndim, + * int ndim_other) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1364 + * + * @cname('__pyx_memoryview_refcount_copying') + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< + * int ndim, bint inc) nogil: + * + */ + +static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_dtype_is_object, int __pyx_v_ndim, int __pyx_v_inc) { + int __pyx_t_1; + + /* "View.MemoryView":1368 + * + * + * if dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, + * dst.strides, ndim, inc) + */ + __pyx_t_1 = (__pyx_v_dtype_is_object != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1369 + * + * if dtype_is_object: + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, # <<<<<<<<<<<<<< + * dst.strides, ndim, inc) + * + */ + __pyx_memoryview_refcount_objects_in_slice_with_gil(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_inc); + + /* "View.MemoryView":1368 + * + * + * if dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, + * dst.strides, ndim, inc) + */ + } + + /* "View.MemoryView":1364 + * + * @cname('__pyx_memoryview_refcount_copying') + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< + * int ndim, bint inc) nogil: + * + */ + + /* function exit code */ +} + +/* "View.MemoryView":1373 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') + * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * bint inc) with gil: + */ + +static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { + __Pyx_RefNannyDeclarations + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("refcount_objects_in_slice_with_gil", 0); + + /* "View.MemoryView":1376 + * Py_ssize_t *strides, int ndim, + * bint inc) with gil: + * refcount_objects_in_slice(data, shape, strides, ndim, inc) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') + */ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, __pyx_v_shape, __pyx_v_strides, __pyx_v_ndim, __pyx_v_inc); + + /* "View.MemoryView":1373 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') + * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * bint inc) with gil: + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif +} + +/* "View.MemoryView":1379 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') + * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, bint inc): + * cdef Py_ssize_t i + */ + +static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + __Pyx_RefNannySetupContext("refcount_objects_in_slice", 0); + + /* "View.MemoryView":1383 + * cdef Py_ssize_t i + * + * for i in range(shape[0]): # <<<<<<<<<<<<<< + * if ndim == 1: + * if inc: + */ + __pyx_t_1 = (__pyx_v_shape[0]); + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_i = __pyx_t_3; + + /* "View.MemoryView":1384 + * + * for i in range(shape[0]): + * if ndim == 1: # <<<<<<<<<<<<<< + * if inc: + * Py_INCREF(( data)[0]) + */ + __pyx_t_4 = ((__pyx_v_ndim == 1) != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":1385 + * for i in range(shape[0]): + * if ndim == 1: + * if inc: # <<<<<<<<<<<<<< + * Py_INCREF(( data)[0]) + * else: + */ + __pyx_t_4 = (__pyx_v_inc != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":1386 + * if ndim == 1: + * if inc: + * Py_INCREF(( data)[0]) # <<<<<<<<<<<<<< + * else: + * Py_DECREF(( data)[0]) + */ + Py_INCREF((((PyObject **)__pyx_v_data)[0])); + + /* "View.MemoryView":1385 + * for i in range(shape[0]): + * if ndim == 1: + * if inc: # <<<<<<<<<<<<<< + * Py_INCREF(( data)[0]) + * else: + */ + goto __pyx_L6; + } + + /* "View.MemoryView":1388 + * Py_INCREF(( data)[0]) + * else: + * Py_DECREF(( data)[0]) # <<<<<<<<<<<<<< + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, + */ + /*else*/ { + Py_DECREF((((PyObject **)__pyx_v_data)[0])); + } + __pyx_L6:; + + /* "View.MemoryView":1384 + * + * for i in range(shape[0]): + * if ndim == 1: # <<<<<<<<<<<<<< + * if inc: + * Py_INCREF(( data)[0]) + */ + goto __pyx_L5; + } + + /* "View.MemoryView":1390 + * Py_DECREF(( data)[0]) + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< + * ndim - 1, inc) + * + */ + /*else*/ { + + /* "View.MemoryView":1391 + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, + * ndim - 1, inc) # <<<<<<<<<<<<<< + * + * data += strides[0] + */ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_inc); + } + __pyx_L5:; + + /* "View.MemoryView":1393 + * ndim - 1, inc) + * + * data += strides[0] # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_data = (__pyx_v_data + (__pyx_v_strides[0])); + } + + /* "View.MemoryView":1379 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') + * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, bint inc): + * cdef Py_ssize_t i + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":1399 + * + * @cname('__pyx_memoryview_slice_assign_scalar') + * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< + * size_t itemsize, void *item, + * bint dtype_is_object) nogil: + */ + +static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item, int __pyx_v_dtype_is_object) { + + /* "View.MemoryView":1402 + * size_t itemsize, void *item, + * bint dtype_is_object) nogil: + * refcount_copying(dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, + * itemsize, item) + */ + __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1403 + * bint dtype_is_object) nogil: + * refcount_copying(dst, dtype_is_object, ndim, False) + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, # <<<<<<<<<<<<<< + * itemsize, item) + * refcount_copying(dst, dtype_is_object, ndim, True) + */ + __pyx_memoryview__slice_assign_scalar(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_itemsize, __pyx_v_item); + + /* "View.MemoryView":1405 + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, + * itemsize, item) + * refcount_copying(dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * + * + */ + __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1399 + * + * @cname('__pyx_memoryview_slice_assign_scalar') + * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< + * size_t itemsize, void *item, + * bint dtype_is_object) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1409 + * + * @cname('__pyx_memoryview__slice_assign_scalar') + * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * size_t itemsize, void *item) nogil: + */ + +static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + Py_ssize_t __pyx_v_stride; + Py_ssize_t __pyx_v_extent; + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + + /* "View.MemoryView":1413 + * size_t itemsize, void *item) nogil: + * cdef Py_ssize_t i + * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t extent = shape[0] + * + */ + __pyx_v_stride = (__pyx_v_strides[0]); + + /* "View.MemoryView":1414 + * cdef Py_ssize_t i + * cdef Py_ssize_t stride = strides[0] + * cdef Py_ssize_t extent = shape[0] # <<<<<<<<<<<<<< + * + * if ndim == 1: + */ + __pyx_v_extent = (__pyx_v_shape[0]); + + /* "View.MemoryView":1416 + * cdef Py_ssize_t extent = shape[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * for i in range(extent): + * memcpy(data, item, itemsize) + */ + __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1417 + * + * if ndim == 1: + * for i in range(extent): # <<<<<<<<<<<<<< + * memcpy(data, item, itemsize) + * data += stride + */ + __pyx_t_2 = __pyx_v_extent; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1418 + * if ndim == 1: + * for i in range(extent): + * memcpy(data, item, itemsize) # <<<<<<<<<<<<<< + * data += stride + * else: + */ + (void)(memcpy(__pyx_v_data, __pyx_v_item, __pyx_v_itemsize)); + + /* "View.MemoryView":1419 + * for i in range(extent): + * memcpy(data, item, itemsize) + * data += stride # <<<<<<<<<<<<<< + * else: + * for i in range(extent): + */ + __pyx_v_data = (__pyx_v_data + __pyx_v_stride); + } + + /* "View.MemoryView":1416 + * cdef Py_ssize_t extent = shape[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * for i in range(extent): + * memcpy(data, item, itemsize) + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1421 + * data += stride + * else: + * for i in range(extent): # <<<<<<<<<<<<<< + * _slice_assign_scalar(data, shape + 1, strides + 1, + * ndim - 1, itemsize, item) + */ + /*else*/ { + __pyx_t_2 = __pyx_v_extent; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1422 + * else: + * for i in range(extent): + * _slice_assign_scalar(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< + * ndim - 1, itemsize, item) + * data += stride + */ + __pyx_memoryview__slice_assign_scalar(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize, __pyx_v_item); + + /* "View.MemoryView":1424 + * _slice_assign_scalar(data, shape + 1, strides + 1, + * ndim - 1, itemsize, item) + * data += stride # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_data = (__pyx_v_data + __pyx_v_stride); + } + } + __pyx_L3:; + + /* "View.MemoryView":1409 + * + * @cname('__pyx_memoryview__slice_assign_scalar') + * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * size_t itemsize, void *item) nogil: + */ + + /* function exit code */ +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum = {"__pyx_unpickle_Enum", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Enum") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 0); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__24, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError); + __pyx_t_4 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) # <<<<<<<<<<<<<< + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_INCREF(__pyx_v___pyx_PickleError); + __pyx_t_1 = __pyx_v___pyx_PickleError; __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_MemviewEnum_type), __pyx_n_s_new); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v___pyx_type); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result = __pyx_t_4; + __pyx_t_4 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_3 = (__pyx_v___pyx_state != Py_None); + __pyx_t_2 = (__pyx_t_3 != 0); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||((void)PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 9, __pyx_L1_error) + __pyx_t_4 = __pyx_unpickle_Enum__set_state(((struct __pyx_MemviewEnum_obj *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 0); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->name); + __Pyx_DECREF(__pyx_v___pyx_result->name); + __pyx_v___pyx_result->name = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 13, __pyx_L1_error) + } + __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_4 = ((__pyx_t_3 > 1) != 0); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_4 != 0); + __pyx_t_2 = __pyx_t_5; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 14, __pyx_L1_error) + } + __pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static struct __pyx_vtabstruct_array __pyx_vtable_array; + +static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_array_obj *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_array_obj *)o); + p->__pyx_vtab = __pyx_vtabptr_array; + p->mode = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_format = ((PyObject*)Py_None); Py_INCREF(Py_None); + if (unlikely(__pyx_array___cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_array(PyObject *o) { + struct __pyx_array_obj *p = (struct __pyx_array_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_array___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->mode); + Py_CLEAR(p->_format); + (*Py_TYPE(o)->tp_free)(o); +} +static PyObject *__pyx_sq_item_array(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_array(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_array___setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyObject *__pyx_tp_getattro_array(PyObject *o, PyObject *n) { + PyObject *v = __Pyx_PyObject_GenericGetAttr(o, n); + if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + v = __pyx_array___getattr__(o, n); + } + return v; +} + +static PyObject *__pyx_getprop___pyx_array_memview(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(o); +} + +static PyMethodDef __pyx_methods_array[] = { + {"__getattr__", (PyCFunction)__pyx_array___getattr__, METH_O|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_array_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_array_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_array[] = { + {(char *)"memview", __pyx_getprop___pyx_array_memview, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_array = { + __pyx_array___len__, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_array, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_array = { + __pyx_array___len__, /*mp_length*/ + __pyx_array___getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_array, /*mp_ass_subscript*/ +}; + +static PyBufferProcs __pyx_tp_as_buffer_array = { + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getreadbuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getwritebuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getsegcount*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getcharbuffer*/ + #endif + __pyx_array_getbuffer, /*bf_getbuffer*/ + 0, /*bf_releasebuffer*/ +}; + +static PyTypeObject __pyx_type___pyx_array = { + PyVarObject_HEAD_INIT(0, 0) + "zoo.board_games.tictactoe.envs.get_done_winner_cython.array", /*tp_name*/ + sizeof(struct __pyx_array_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_array, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_array, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_array, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + __pyx_tp_getattro_array, /*tp_getattro*/ + 0, /*tp_setattro*/ + &__pyx_tp_as_buffer_array, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_array, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_array, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_array, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + 0, /*tp_pypy_flags*/ + #endif +}; + +static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_MemviewEnum_obj *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_MemviewEnum_obj *)o); + p->name = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_Enum(PyObject *o) { + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->name); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_Enum(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + if (p->name) { + e = (*v)(p->name, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_Enum(PyObject *o) { + PyObject* tmp; + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + tmp = ((PyObject*)p->name); + p->name = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyMethodDef __pyx_methods_Enum[] = { + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type___pyx_MemviewEnum = { + PyVarObject_HEAD_INIT(0, 0) + "zoo.board_games.tictactoe.envs.get_done_winner_cython.Enum", /*tp_name*/ + sizeof(struct __pyx_MemviewEnum_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_Enum, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_MemviewEnum___repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_Enum, /*tp_traverse*/ + __pyx_tp_clear_Enum, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_Enum, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_MemviewEnum___init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_Enum, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + 0, /*tp_pypy_flags*/ + #endif +}; +static struct __pyx_vtabstruct_memoryview __pyx_vtable_memoryview; + +static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_memoryview_obj *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_memoryview_obj *)o); + p->__pyx_vtab = __pyx_vtabptr_memoryview; + p->obj = Py_None; Py_INCREF(Py_None); + p->_size = Py_None; Py_INCREF(Py_None); + p->_array_interface = Py_None; Py_INCREF(Py_None); + p->view.obj = NULL; + if (unlikely(__pyx_memoryview___cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_memoryview(PyObject *o) { + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_memoryview___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->obj); + Py_CLEAR(p->_size); + Py_CLEAR(p->_array_interface); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_memoryview(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + if (p->obj) { + e = (*v)(p->obj, a); if (e) return e; + } + if (p->_size) { + e = (*v)(p->_size, a); if (e) return e; + } + if (p->_array_interface) { + e = (*v)(p->_array_interface, a); if (e) return e; + } + if (p->view.obj) { + e = (*v)(p->view.obj, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_memoryview(PyObject *o) { + PyObject* tmp; + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + tmp = ((PyObject*)p->obj); + p->obj = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_size); + p->_size = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_array_interface); + p->_array_interface = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + Py_CLEAR(p->view.obj); + return 0; +} +static PyObject *__pyx_sq_item_memoryview(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_memoryview(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_memoryview___setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyObject *__pyx_getprop___pyx_memoryview_T(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_base(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_shape(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_strides(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_suboffsets(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_ndim(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_itemsize(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_nbytes(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_size(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(o); +} + +static PyMethodDef __pyx_methods_memoryview[] = { + {"is_c_contig", (PyCFunction)__pyx_memoryview_is_c_contig, METH_NOARGS, 0}, + {"is_f_contig", (PyCFunction)__pyx_memoryview_is_f_contig, METH_NOARGS, 0}, + {"copy", (PyCFunction)__pyx_memoryview_copy, METH_NOARGS, 0}, + {"copy_fortran", (PyCFunction)__pyx_memoryview_copy_fortran, METH_NOARGS, 0}, + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_memoryview[] = { + {(char *)"T", __pyx_getprop___pyx_memoryview_T, 0, (char *)0, 0}, + {(char *)"base", __pyx_getprop___pyx_memoryview_base, 0, (char *)0, 0}, + {(char *)"shape", __pyx_getprop___pyx_memoryview_shape, 0, (char *)0, 0}, + {(char *)"strides", __pyx_getprop___pyx_memoryview_strides, 0, (char *)0, 0}, + {(char *)"suboffsets", __pyx_getprop___pyx_memoryview_suboffsets, 0, (char *)0, 0}, + {(char *)"ndim", __pyx_getprop___pyx_memoryview_ndim, 0, (char *)0, 0}, + {(char *)"itemsize", __pyx_getprop___pyx_memoryview_itemsize, 0, (char *)0, 0}, + {(char *)"nbytes", __pyx_getprop___pyx_memoryview_nbytes, 0, (char *)0, 0}, + {(char *)"size", __pyx_getprop___pyx_memoryview_size, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_memoryview = { + __pyx_memoryview___len__, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_memoryview, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_memoryview = { + __pyx_memoryview___len__, /*mp_length*/ + __pyx_memoryview___getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_memoryview, /*mp_ass_subscript*/ +}; + +static PyBufferProcs __pyx_tp_as_buffer_memoryview = { + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getreadbuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getwritebuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getsegcount*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getcharbuffer*/ + #endif + __pyx_memoryview_getbuffer, /*bf_getbuffer*/ + 0, /*bf_releasebuffer*/ +}; + +static PyTypeObject __pyx_type___pyx_memoryview = { + PyVarObject_HEAD_INIT(0, 0) + "zoo.board_games.tictactoe.envs.get_done_winner_cython.memoryview", /*tp_name*/ + sizeof(struct __pyx_memoryview_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_memoryview, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_memoryview___repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_memoryview, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_memoryview, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + __pyx_memoryview___str__, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + &__pyx_tp_as_buffer_memoryview, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_memoryview, /*tp_traverse*/ + __pyx_tp_clear_memoryview, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_memoryview, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_memoryview, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_memoryview, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + 0, /*tp_pypy_flags*/ + #endif +}; +static struct __pyx_vtabstruct__memoryviewslice __pyx_vtable__memoryviewslice; + +static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_memoryviewslice_obj *p; + PyObject *o = __pyx_tp_new_memoryview(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_memoryviewslice_obj *)o); + p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_memoryview*)__pyx_vtabptr__memoryviewslice; + p->from_object = Py_None; Py_INCREF(Py_None); + p->from_slice.memview = NULL; + return o; +} + +static void __pyx_tp_dealloc__memoryviewslice(PyObject *o) { + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_memoryviewslice___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->from_object); + PyObject_GC_Track(o); + __pyx_tp_dealloc_memoryview(o); +} + +static int __pyx_tp_traverse__memoryviewslice(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + e = __pyx_tp_traverse_memoryview(o, v, a); if (e) return e; + if (p->from_object) { + e = (*v)(p->from_object, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear__memoryviewslice(PyObject *o) { + PyObject* tmp; + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + __pyx_tp_clear_memoryview(o); + tmp = ((PyObject*)p->from_object); + p->from_object = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + __PYX_XDEC_MEMVIEW(&p->from_slice, 1); + return 0; +} + +static PyObject *__pyx_getprop___pyx_memoryviewslice_base(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(o); +} + +static PyMethodDef __pyx_methods__memoryviewslice[] = { + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets__memoryviewslice[] = { + {(char *)"base", __pyx_getprop___pyx_memoryviewslice_base, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type___pyx_memoryviewslice = { + PyVarObject_HEAD_INIT(0, 0) + "zoo.board_games.tictactoe.envs.get_done_winner_cython._memoryviewslice", /*tp_name*/ + sizeof(struct __pyx_memoryviewslice_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc__memoryviewslice, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + #if CYTHON_COMPILING_IN_PYPY + __pyx_memoryview___repr__, /*tp_repr*/ + #else + 0, /*tp_repr*/ + #endif + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + #if CYTHON_COMPILING_IN_PYPY + __pyx_memoryview___str__, /*tp_str*/ + #else + 0, /*tp_str*/ + #endif + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + "Internal class for passing memoryview slices to Python", /*tp_doc*/ + __pyx_tp_traverse__memoryviewslice, /*tp_traverse*/ + __pyx_tp_clear__memoryviewslice, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods__memoryviewslice, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets__memoryviewslice, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new__memoryviewslice, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + 0, /*tp_pypy_flags*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {"get_done_winner_cython", (PyCFunction)__pyx_pw_3zoo_11board_games_9tictactoe_4envs_22get_done_winner_cython_1get_done_winner_cython, METH_O, __pyx_doc_3zoo_11board_games_9tictactoe_4envs_22get_done_winner_cython_get_done_winner_cython}, + {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_get_done_winner_cython(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_get_done_winner_cython}, + {0, NULL} +}; +#endif + +static struct PyModuleDef __pyx_moduledef = { + PyModuleDef_HEAD_INIT, + "get_done_winner_cython", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_ASCII, __pyx_k_ASCII, sizeof(__pyx_k_ASCII), 0, 0, 1, 1}, + {&__pyx_kp_s_Buffer_view_does_not_expose_stri, __pyx_k_Buffer_view_does_not_expose_stri, sizeof(__pyx_k_Buffer_view_does_not_expose_stri), 0, 0, 1, 0}, + {&__pyx_kp_s_Can_only_create_a_buffer_that_is, __pyx_k_Can_only_create_a_buffer_that_is, sizeof(__pyx_k_Can_only_create_a_buffer_that_is), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_assign_to_read_only_memor, __pyx_k_Cannot_assign_to_read_only_memor, sizeof(__pyx_k_Cannot_assign_to_read_only_memor), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_create_writable_memory_vi, __pyx_k_Cannot_create_writable_memory_vi, sizeof(__pyx_k_Cannot_create_writable_memory_vi), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_index_with_type_s, __pyx_k_Cannot_index_with_type_s, sizeof(__pyx_k_Cannot_index_with_type_s), 0, 0, 1, 0}, + {&__pyx_n_s_Ellipsis, __pyx_k_Ellipsis, sizeof(__pyx_k_Ellipsis), 0, 0, 1, 1}, + {&__pyx_kp_s_Empty_shape_tuple_for_cython_arr, __pyx_k_Empty_shape_tuple_for_cython_arr, sizeof(__pyx_k_Empty_shape_tuple_for_cython_arr), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 0, 1, 0}, + {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1}, + {&__pyx_kp_s_Indirect_dimensions_not_supporte, __pyx_k_Indirect_dimensions_not_supporte, sizeof(__pyx_k_Indirect_dimensions_not_supporte), 0, 0, 1, 0}, + {&__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_k_Invalid_mode_expected_c_or_fortr, sizeof(__pyx_k_Invalid_mode_expected_c_or_fortr), 0, 0, 1, 0}, + {&__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_k_Invalid_shape_in_axis_d_d, sizeof(__pyx_k_Invalid_shape_in_axis_d_d), 0, 0, 1, 0}, + {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, + {&__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_k_MemoryView_of_r_at_0x_x, sizeof(__pyx_k_MemoryView_of_r_at_0x_x), 0, 0, 1, 0}, + {&__pyx_kp_s_MemoryView_of_r_object, __pyx_k_MemoryView_of_r_object, sizeof(__pyx_k_MemoryView_of_r_object), 0, 0, 1, 0}, + {&__pyx_n_b_O, __pyx_k_O, sizeof(__pyx_k_O), 0, 0, 0, 1}, + {&__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_k_Out_of_bounds_on_buffer_access_a, sizeof(__pyx_k_Out_of_bounds_on_buffer_access_a), 0, 0, 1, 0}, + {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_kp_s_Unable_to_convert_item_to_object, __pyx_k_Unable_to_convert_item_to_object, sizeof(__pyx_k_Unable_to_convert_item_to_object), 0, 0, 1, 0}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_View_MemoryView, __pyx_k_View_MemoryView, sizeof(__pyx_k_View_MemoryView), 0, 0, 1, 1}, + {&__pyx_n_s_allocate_buffer, __pyx_k_allocate_buffer, sizeof(__pyx_k_allocate_buffer), 0, 0, 1, 1}, + {&__pyx_n_s_base, __pyx_k_base, sizeof(__pyx_k_base), 0, 0, 1, 1}, + {&__pyx_n_s_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 0, 1, 1}, + {&__pyx_n_u_c, __pyx_k_c, sizeof(__pyx_k_c), 0, 1, 0, 1}, + {&__pyx_n_s_class, __pyx_k_class, sizeof(__pyx_k_class), 0, 0, 1, 1}, + {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1}, + {&__pyx_kp_s_contiguous_and_direct, __pyx_k_contiguous_and_direct, sizeof(__pyx_k_contiguous_and_direct), 0, 0, 1, 0}, + {&__pyx_kp_s_contiguous_and_indirect, __pyx_k_contiguous_and_indirect, sizeof(__pyx_k_contiguous_and_indirect), 0, 0, 1, 0}, + {&__pyx_n_s_dict, __pyx_k_dict, sizeof(__pyx_k_dict), 0, 0, 1, 1}, + {&__pyx_n_s_dtype_is_object, __pyx_k_dtype_is_object, sizeof(__pyx_k_dtype_is_object), 0, 0, 1, 1}, + {&__pyx_n_s_encode, __pyx_k_encode, sizeof(__pyx_k_encode), 0, 0, 1, 1}, + {&__pyx_n_s_enumerate, __pyx_k_enumerate, sizeof(__pyx_k_enumerate), 0, 0, 1, 1}, + {&__pyx_n_s_error, __pyx_k_error, sizeof(__pyx_k_error), 0, 0, 1, 1}, + {&__pyx_n_s_flags, __pyx_k_flags, sizeof(__pyx_k_flags), 0, 0, 1, 1}, + {&__pyx_n_s_format, __pyx_k_format, sizeof(__pyx_k_format), 0, 0, 1, 1}, + {&__pyx_n_s_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 0, 1, 1}, + {&__pyx_n_u_fortran, __pyx_k_fortran, sizeof(__pyx_k_fortran), 0, 1, 0, 1}, + {&__pyx_n_s_getstate, __pyx_k_getstate, sizeof(__pyx_k_getstate), 0, 0, 1, 1}, + {&__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_k_got_differing_extents_in_dimensi, sizeof(__pyx_k_got_differing_extents_in_dimensi), 0, 0, 1, 0}, + {&__pyx_n_s_id, __pyx_k_id, sizeof(__pyx_k_id), 0, 0, 1, 1}, + {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1}, + {&__pyx_n_s_itemsize, __pyx_k_itemsize, sizeof(__pyx_k_itemsize), 0, 0, 1, 1}, + {&__pyx_kp_s_itemsize_0_for_cython_array, __pyx_k_itemsize_0_for_cython_array, sizeof(__pyx_k_itemsize_0_for_cython_array), 0, 0, 1, 0}, + {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1}, + {&__pyx_n_s_memview, __pyx_k_memview, sizeof(__pyx_k_memview), 0, 0, 1, 1}, + {&__pyx_n_s_mode, __pyx_k_mode, sizeof(__pyx_k_mode), 0, 0, 1, 1}, + {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1}, + {&__pyx_n_s_name_2, __pyx_k_name_2, sizeof(__pyx_k_name_2), 0, 0, 1, 1}, + {&__pyx_n_s_ndim, __pyx_k_ndim, sizeof(__pyx_k_ndim), 0, 0, 1, 1}, + {&__pyx_n_s_new, __pyx_k_new, sizeof(__pyx_k_new), 0, 0, 1, 1}, + {&__pyx_kp_s_no_default___reduce___due_to_non, __pyx_k_no_default___reduce___due_to_non, sizeof(__pyx_k_no_default___reduce___due_to_non), 0, 0, 1, 0}, + {&__pyx_n_s_obj, __pyx_k_obj, sizeof(__pyx_k_obj), 0, 0, 1, 1}, + {&__pyx_n_s_pack, __pyx_k_pack, sizeof(__pyx_k_pack), 0, 0, 1, 1}, + {&__pyx_n_s_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_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}, + {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, 24, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 134, __pyx_L1_error) + __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 149, __pyx_L1_error) + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 152, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) + __pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_n_s_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(1, 406, __pyx_L1_error) + __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(1, 615, __pyx_L1_error) + __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 834, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":21 + * cdef int32_t i, j, player, x, y, count + * cdef bint has_legal_actions = False + * cdef directions = ((1, -1), (1, 0), (1, 1), (0, 1)) # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple_ = PyTuple_Pack(2, __pyx_int_1, __pyx_int_neg_1); if (unlikely(!__pyx_tuple_)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + __pyx_tuple__2 = PyTuple_Pack(2, __pyx_int_1, __pyx_int_0); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + __pyx_tuple__3 = PyTuple_Pack(2, __pyx_int_1, __pyx_int_1); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + __pyx_tuple__4 = PyTuple_Pack(2, __pyx_int_0, __pyx_int_1); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + __pyx_tuple__5 = PyTuple_Pack(4, __pyx_tuple_, __pyx_tuple__2, __pyx_tuple__3, __pyx_tuple__4); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 21, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "View.MemoryView":134 + * + * if not self.ndim: + * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< + * + * if itemsize <= 0: + */ + __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_Empty_shape_tuple_for_cython_arr); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + + /* "View.MemoryView":137 + * + * if itemsize <= 0: + * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< + * + * if not isinstance(format, bytes): + */ + __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_itemsize_0_for_cython_array); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + + /* "View.MemoryView":149 + * + * if not self._shape: + * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_shape_and_str); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "View.MemoryView":177 + * self.data = malloc(self.len) + * if not self.data: + * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< + * + * if self.dtype_is_object: + */ + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_array_data); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + + /* "View.MemoryView":193 + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") # <<<<<<<<<<<<<< + * info.buf = self.data + * info.len = self.len + */ + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_Can_only_create_a_buffer_that_is); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + + /* "(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__11 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + /* "(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__12 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "View.MemoryView":420 + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< + * + * have_slices, index = _unellipsify(index, self.view.ndim) + */ + __pyx_tuple__13 = PyTuple_Pack(1, __pyx_kp_s_Cannot_assign_to_read_only_memor); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + + /* "View.MemoryView":497 + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< + * else: + * if len(self.view.format) == 1: + */ + __pyx_tuple__14 = PyTuple_Pack(1, __pyx_kp_s_Unable_to_convert_item_to_object); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); + + /* "View.MemoryView":522 + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<< + * + * if flags & PyBUF_ND: + */ + __pyx_tuple__15 = PyTuple_Pack(1, __pyx_kp_s_Cannot_create_writable_memory_vi); if (unlikely(!__pyx_tuple__15)) __PYX_ERR(1, 522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__15); + __Pyx_GIVEREF(__pyx_tuple__15); + + /* "View.MemoryView":572 + * if self.view.strides == NULL: + * + * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) + */ + __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_Buffer_view_does_not_expose_stri); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(1, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); + + /* "View.MemoryView":579 + * def suboffsets(self): + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) + */ + __pyx_tuple__17 = PyTuple_New(1); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(1, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__17); + __Pyx_INCREF(__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_int_neg_1); + PyTuple_SET_ITEM(__pyx_tuple__17, 0, __pyx_int_neg_1); + __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":684 + * if item is Ellipsis: + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<< + * seen_ellipsis = True + * else: + */ + __pyx_slice__20 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__20)) __PYX_ERR(1, 684, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__20); + __Pyx_GIVEREF(__pyx_slice__20); + + /* "View.MemoryView":705 + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + * raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__21 = PyTuple_Pack(1, __pyx_kp_s_Indirect_dimensions_not_supporte); if (unlikely(!__pyx_tuple__21)) __PYX_ERR(1, 705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__21); + __Pyx_GIVEREF(__pyx_tuple__21); + + /* "(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__22 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__22); + __Pyx_GIVEREF(__pyx_tuple__22); + + /* "(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__23 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__23); + __Pyx_GIVEREF(__pyx_tuple__23); + __pyx_tuple__24 = PyTuple_Pack(3, __pyx_int_184977713, __pyx_int_136983863, __pyx_int_112105877); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__24); + __Pyx_GIVEREF(__pyx_tuple__24); + + /* "View.MemoryView":287 + * return self.name + * + * cdef generic = Enum("") # <<<<<<<<<<<<<< + * cdef strided = Enum("") # default + * cdef indirect = Enum("") + */ + __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(1, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__25); + __Pyx_GIVEREF(__pyx_tuple__25); + + /* "View.MemoryView":288 + * + * cdef generic = Enum("") + * cdef strided = Enum("") # default # <<<<<<<<<<<<<< + * cdef indirect = Enum("") + * + */ + __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(1, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__26); + __Pyx_GIVEREF(__pyx_tuple__26); + + /* "View.MemoryView":289 + * cdef generic = Enum("") + * cdef strided = Enum("") # default + * cdef indirect = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__27 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__27)) __PYX_ERR(1, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__27); + __Pyx_GIVEREF(__pyx_tuple__27); + + /* "View.MemoryView":292 + * + * + * cdef contiguous = Enum("") # <<<<<<<<<<<<<< + * cdef indirect_contiguous = Enum("") + * + */ + __pyx_tuple__28 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__28)) __PYX_ERR(1, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__28); + __Pyx_GIVEREF(__pyx_tuple__28); + + /* "View.MemoryView":293 + * + * cdef contiguous = Enum("") + * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__29 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__29)) __PYX_ERR(1, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__29); + __Pyx_GIVEREF(__pyx_tuple__29); + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + __pyx_tuple__30 = 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__30)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__30); + __Pyx_GIVEREF(__pyx_tuple__30); + __pyx_codeobj__31 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__30, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__31)) __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) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_112105877 = PyInt_FromLong(112105877L); if (unlikely(!__pyx_int_112105877)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_136983863 = PyInt_FromLong(136983863L); if (unlikely(!__pyx_int_136983863)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_184977713 = PyInt_FromLong(184977713L); if (unlikely(!__pyx_int_184977713)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ + +static int __Pyx_modinit_global_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + generic = Py_None; Py_INCREF(Py_None); + strided = Py_None; Py_INCREF(Py_None); + indirect = Py_None; Py_INCREF(Py_None); + contiguous = Py_None; Py_INCREF(Py_None); + indirect_contiguous = Py_None; Py_INCREF(Py_None); + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + __pyx_vtabptr_array = &__pyx_vtable_array; + __pyx_vtable_array.get_memview = (PyObject *(*)(struct __pyx_array_obj *))__pyx_array_get_memview; + if (PyType_Ready(&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_array.tp_print = 0; + #endif + if (__Pyx_SetVtable(__pyx_type___pyx_array.tp_dict, __pyx_vtabptr_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) + __pyx_array_type = &__pyx_type___pyx_array; + if (PyType_Ready(&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 280, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_MemviewEnum.tp_print = 0; + #endif + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_MemviewEnum.tp_dictoffset && __pyx_type___pyx_MemviewEnum.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type___pyx_MemviewEnum.tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 280, __pyx_L1_error) + __pyx_MemviewEnum_type = &__pyx_type___pyx_MemviewEnum; + __pyx_vtabptr_memoryview = &__pyx_vtable_memoryview; + __pyx_vtable_memoryview.get_item_pointer = (char *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_get_item_pointer; + __pyx_vtable_memoryview.is_slice = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_is_slice; + __pyx_vtable_memoryview.setitem_slice_assignment = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_slice_assignment; + __pyx_vtable_memoryview.setitem_slice_assign_scalar = (PyObject *(*)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_setitem_slice_assign_scalar; + __pyx_vtable_memoryview.setitem_indexed = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_indexed; + __pyx_vtable_memoryview.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryview_convert_item_to_object; + __pyx_vtable_memoryview.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryview_assign_item_from_object; + if (PyType_Ready(&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_memoryview.tp_print = 0; + #endif + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryview.tp_dictoffset && __pyx_type___pyx_memoryview.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type___pyx_memoryview.tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + if (__Pyx_SetVtable(__pyx_type___pyx_memoryview.tp_dict, __pyx_vtabptr_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) + __pyx_memoryview_type = &__pyx_type___pyx_memoryview; + __pyx_vtabptr__memoryviewslice = &__pyx_vtable__memoryviewslice; + __pyx_vtable__memoryviewslice.__pyx_base = *__pyx_vtabptr_memoryview; + __pyx_vtable__memoryviewslice.__pyx_base.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryviewslice_convert_item_to_object; + __pyx_vtable__memoryviewslice.__pyx_base.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryviewslice_assign_item_from_object; + __pyx_type___pyx_memoryviewslice.tp_base = __pyx_memoryview_type; + if (PyType_Ready(&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_memoryviewslice.tp_print = 0; + #endif + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryviewslice.tp_dictoffset && __pyx_type___pyx_memoryviewslice.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type___pyx_memoryviewslice.tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + if (__Pyx_SetVtable(__pyx_type___pyx_memoryviewslice.tp_dict, __pyx_vtabptr__memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) + __pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyObject * +#endif +#endif + + +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initget_done_winner_cython(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initget_done_winner_cython(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_get_done_winner_cython(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_get_done_winner_cython(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_get_done_winner_cython(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 'get_done_winner_cython' 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_get_done_winner_cython(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + PyEval_InitThreads(); + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("get_done_winner_cython", __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_zoo__board_games__tictactoe__envs__get_done_winner_cython) { + 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, "zoo.board_games.tictactoe.envs.get_done_winner_cython")) { + if (unlikely(PyDict_SetItemString(modules, "zoo.board_games.tictactoe.envs.get_done_winner_cython", __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 + + /* "zoo/board_games/tictactoe/envs/get_done_winner_cython.pyx":1 + * from libc.stdint cimport int32_t # <<<<<<<<<<<<<< + * cimport cython + * + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":210 + * info.obj = self + * + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * def __dealloc__(array self): + */ + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_array_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_array_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 210, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_array_type); + + /* "View.MemoryView":287 + * return self.name + * + * cdef generic = Enum("") # <<<<<<<<<<<<<< + * cdef strided = Enum("") # default + * cdef indirect = Enum("") + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(generic); + __Pyx_DECREF_SET(generic, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":288 + * + * cdef generic = Enum("") + * cdef strided = Enum("") # default # <<<<<<<<<<<<<< + * cdef indirect = Enum("") + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(strided); + __Pyx_DECREF_SET(strided, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":289 + * cdef generic = Enum("") + * cdef strided = Enum("") # default + * cdef indirect = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__27, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(indirect); + __Pyx_DECREF_SET(indirect, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":292 + * + * + * cdef contiguous = Enum("") # <<<<<<<<<<<<<< + * cdef indirect_contiguous = Enum("") + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__28, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(contiguous); + __Pyx_DECREF_SET(contiguous, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":293 + * + * cdef contiguous = Enum("") + * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__29, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(indirect_contiguous); + __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":317 + * + * DEF THREAD_LOCKS_PREALLOCATED = 8 + * cdef int __pyx_memoryview_thread_locks_used = 0 # <<<<<<<<<<<<<< + * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ + * PyThread_allocate_lock(), + */ + __pyx_memoryview_thread_locks_used = 0; + + /* "View.MemoryView":318 + * DEF THREAD_LOCKS_PREALLOCATED = 8 + * cdef int __pyx_memoryview_thread_locks_used = 0 + * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ # <<<<<<<<<<<<<< + * PyThread_allocate_lock(), + * PyThread_allocate_lock(), + */ + __pyx_t_2[0] = PyThread_allocate_lock(); + __pyx_t_2[1] = PyThread_allocate_lock(); + __pyx_t_2[2] = PyThread_allocate_lock(); + __pyx_t_2[3] = PyThread_allocate_lock(); + __pyx_t_2[4] = PyThread_allocate_lock(); + __pyx_t_2[5] = PyThread_allocate_lock(); + __pyx_t_2[6] = PyThread_allocate_lock(); + __pyx_t_2[7] = PyThread_allocate_lock(); + memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_2, sizeof(__pyx_memoryview_thread_locks[0]) * (8)); + + /* "View.MemoryView":551 + * info.obj = self + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 551, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_memoryview_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 551, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_memoryview_type); + + /* "View.MemoryView":997 + * return self.from_object + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 997, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_memoryviewslice_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 997, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_memoryviewslice_type); + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum, NULL, __pyx_n_s_View_MemoryView); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Enum, __pyx_t_1) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init zoo.board_games.tictactoe.envs.get_done_winner_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_CLEAR(__pyx_m); + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init zoo.board_games.tictactoe.envs.get_done_winner_cython"); + } + __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; +} + +/* 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)); +} + +/* None */ +static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname) { + PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); +} + +/* MemviewSliceInit */ +static int +__Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview, + int ndim, + __Pyx_memviewslice *memviewslice, + int memview_is_new_reference) +{ + __Pyx_RefNannyDeclarations + int i, retval=-1; + Py_buffer *buf = &memview->view; + __Pyx_RefNannySetupContext("init_memviewslice", 0); + if (unlikely(memviewslice->memview || memviewslice->data)) { + PyErr_SetString(PyExc_ValueError, + "memviewslice is already initialized!"); + goto fail; + } + if (buf->strides) { + for (i = 0; i < ndim; i++) { + memviewslice->strides[i] = buf->strides[i]; + } + } else { + Py_ssize_t stride = buf->itemsize; + for (i = ndim - 1; i >= 0; i--) { + memviewslice->strides[i] = stride; + stride *= buf->shape[i]; + } + } + for (i = 0; i < ndim; i++) { + memviewslice->shape[i] = buf->shape[i]; + if (buf->suboffsets) { + memviewslice->suboffsets[i] = buf->suboffsets[i]; + } else { + memviewslice->suboffsets[i] = -1; + } + } + memviewslice->memview = memview; + memviewslice->data = (char *)buf->buf; + if (__pyx_add_acquisition_count(memview) == 0 && !memview_is_new_reference) { + Py_INCREF(memview); + } + retval = 0; + goto no_fail; +fail: + memviewslice->memview = 0; + memviewslice->data = 0; + retval = -1; +no_fail: + __Pyx_RefNannyFinishContext(); + return retval; +} +#ifndef Py_NO_RETURN +#define Py_NO_RETURN +#endif +static void __pyx_fatalerror(const char *fmt, ...) Py_NO_RETURN { + va_list vargs; + char msg[200]; +#if PY_VERSION_HEX >= 0x030A0000 || defined(HAVE_STDARG_PROTOTYPES) + va_start(vargs, fmt); +#else + va_start(vargs); +#endif + vsnprintf(msg, 200, fmt, vargs); + va_end(vargs); + Py_FatalError(msg); +} +static CYTHON_INLINE int +__pyx_add_acquisition_count_locked(__pyx_atomic_int *acquisition_count, + PyThread_type_lock lock) +{ + int result; + PyThread_acquire_lock(lock, 1); + result = (*acquisition_count)++; + PyThread_release_lock(lock); + return result; +} +static CYTHON_INLINE int +__pyx_sub_acquisition_count_locked(__pyx_atomic_int *acquisition_count, + PyThread_type_lock lock) +{ + int result; + PyThread_acquire_lock(lock, 1); + result = (*acquisition_count)--; + PyThread_release_lock(lock); + return result; +} +static CYTHON_INLINE void +__Pyx_INC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno) +{ + int first_time; + struct __pyx_memoryview_obj *memview = memslice->memview; + if (unlikely(!memview || (PyObject *) memview == Py_None)) + return; + if (unlikely(__pyx_get_slice_count(memview) < 0)) + __pyx_fatalerror("Acquisition count is %d (line %d)", + __pyx_get_slice_count(memview), lineno); + first_time = __pyx_add_acquisition_count(memview) == 0; + if (unlikely(first_time)) { + if (have_gil) { + Py_INCREF((PyObject *) memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_INCREF((PyObject *) memview); + PyGILState_Release(_gilstate); + } + } +} +static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *memslice, + int have_gil, int lineno) { + int last_time; + struct __pyx_memoryview_obj *memview = memslice->memview; + if (unlikely(!memview || (PyObject *) memview == Py_None)) { + memslice->memview = NULL; + return; + } + if (unlikely(__pyx_get_slice_count(memview) <= 0)) + __pyx_fatalerror("Acquisition count is %d (line %d)", + __pyx_get_slice_count(memview), lineno); + last_time = __pyx_sub_acquisition_count(memview) == 1; + memslice->data = NULL; + if (unlikely(last_time)) { + if (have_gil) { + Py_CLEAR(memslice->memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_CLEAR(memslice->memview); + PyGILState_Release(_gilstate); + } + } else { + memslice->memview = NULL; + } +} + +/* RaiseArgTupleInvalid */ +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* RaiseDoubleKeywords */ +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (exact) { + #if PY_MAJOR_VERSION == 2 + if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); + return 0; +} + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = Py_TYPE(func)->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* RaiseException */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_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 + +/* PyCFunctionFastCall */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + int flags = PyCFunction_GET_FLAGS(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { + return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); + } else { + return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + } +} +#endif + +/* PyFunctionFastCall */ +#if CYTHON_FAST_PYCALL +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif +#endif + +/* PyObjectCall2Args */ +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { + PyObject *args, *result = NULL; + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyFunction_FastCall(function, args, 2); + } + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyCFunction_FastCall(function, args, 2); + } + #endif + args = PyTuple_New(2); + if (unlikely(!args)) goto done; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + Py_INCREF(function); + result = __Pyx_PyObject_Call(function, args, NULL); + Py_DECREF(args); + Py_DECREF(function); +done: + return result; +} + +/* PyObjectCallMethO */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallOneArg */ +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif + if (likely(PyCFunction_Check(func))) { + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (__Pyx_PyFastCFunction_Check(func)) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else +#if PY_MAJOR_VERSION < 3 + PyObject* owned_ref = NULL; +#endif + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); +#if PY_MAJOR_VERSION < 3 + if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { + owned_ref = PyUnicode_FromObject(s2); + if (unlikely(!owned_ref)) + return -1; + s2 = owned_ref; + s2_is_unicode = 1; + } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { + owned_ref = PyUnicode_FromObject(s1); + if (unlikely(!owned_ref)) + return -1; + s1 = owned_ref; + s1_is_unicode = 1; + } else if (((!s2_is_unicode) & (!s1_is_unicode))) { + return __Pyx_PyBytes_Equals(s1, s2, equals); + } +#endif + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length; + int kind; + void *data1, *data2; + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + length = __Pyx_PyUnicode_GET_LENGTH(s1); + if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + #if CYTHON_PEP393_ENABLED + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + #else + hash1 = ((PyUnicodeObject*)s1)->hash; + hash2 = ((PyUnicodeObject*)s2)->hash; + #endif + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ); +return_ne: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_NE); +#endif +} + +/* DivInt[Py_ssize_t] */ +static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t a, Py_ssize_t b) { + Py_ssize_t q = a / b; + Py_ssize_t r = a - q*b; + q -= ((r != 0) & ((r ^ b) < 0)); + return q; +} + +/* GetAttr */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { +#if CYTHON_USE_TYPE_SLOTS +#if PY_MAJOR_VERSION >= 3 + if (likely(PyUnicode_Check(n))) +#else + if (likely(PyString_Check(n))) +#endif + return __Pyx_PyObject_GetAttrStr(o, n); +#endif + return PyObject_GetAttr(o, n); +} + +/* ObjectGetItem */ +#if CYTHON_USE_TYPE_SLOTS +static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { + PyObject *runerr = NULL; + Py_ssize_t key_value; + PySequenceMethods *m = Py_TYPE(obj)->tp_as_sequence; + if (unlikely(!(m && m->sq_item))) { + PyErr_Format(PyExc_TypeError, "'%.200s' object is not subscriptable", Py_TYPE(obj)->tp_name); + return NULL; + } + key_value = __Pyx_PyIndex_AsSsize_t(index); + if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { + return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1); + } + if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { + PyErr_Clear(); + PyErr_Format(PyExc_IndexError, "cannot fit '%.200s' into an index-sized integer", Py_TYPE(index)->tp_name); + } + return NULL; +} +static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key) { + PyMappingMethods *m = Py_TYPE(obj)->tp_as_mapping; + if (likely(m && m->mp_subscript)) { + return m->mp_subscript(obj, key); + } + return __Pyx_PyObject_GetIndex(obj, key); +} +#endif + +/* decode_c_string */ +static CYTHON_INLINE PyObject* __Pyx_decode_c_string( + const char* cstring, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)) { + Py_ssize_t length; + if (unlikely((start < 0) | (stop < 0))) { + size_t slen = strlen(cstring); + if (unlikely(slen > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, + "c-string too long to convert to Python"); + return NULL; + } + length = (Py_ssize_t) slen; + if (start < 0) { + start += length; + if (start < 0) + start = 0; + } + if (stop < 0) + stop += length; + } + if (unlikely(stop <= start)) + return __Pyx_NewRef(__pyx_empty_unicode); + length = stop - start; + cstring += start; + if (decode_func) { + return decode_func(cstring, length, errors); + } else { + return PyUnicode_Decode(cstring, length, encoding, errors); + } +} + +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; icurexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; + if (unlikely(PyTuple_Check(err))) + return __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + return __Pyx_PyErr_GivenExceptionMatches(exc_type, err); +} +#endif + +/* GetAttr3 */ +static PyObject *__Pyx_GetAttr3Default(PyObject *d) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + return NULL; + __Pyx_PyErr_Clear(); + Py_INCREF(d); + return d; +} +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { + PyObject *r = __Pyx_GetAttr(o, n); + return (likely(r)) ? r : __Pyx_GetAttr3Default(d); +} + +/* PyDictVersioning */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif + } + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); +} +#endif + +/* GetModuleGlobalName */ +#if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if !CYTHON_AVOID_BORROWED_REFS +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 + result = _PyDict_GetItem_KnownHash(__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } else if (unlikely(PyErr_Occurred())) { + return NULL; + } +#else + result = PyDict_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } +#endif +#else + result = PyObject_GetItem(__pyx_d, name); + __PYX_UPDATE_DICT_CACHE(__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + +/* RaiseTooManyValuesToUnpack */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +/* RaiseNeedMoreValuesToUnpack */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +/* RaiseNoneIterError */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +/* ExtTypeTest */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + PyErr_Format(PyExc_TypeError, "Cannot convert %.200s to %.200s", + Py_TYPE(obj)->tp_name, type->tp_name); + return 0; +} + +/* GetTopmostException */ +#if CYTHON_USE_EXC_INFO_STACK +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_type == NULL || exc_info->exc_type == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; + } + return exc_info; +} +#endif + +/* SaveResetException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + #endif + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +#endif + +/* GetException */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) +#endif +{ + PyObject *local_type, *local_value, *local_tb; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + #if PY_MAJOR_VERSION >= 3 + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } + #endif + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + } + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +} + +/* SwapException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = *type; + exc_info->exc_value = *value; + exc_info->exc_traceback = *tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = *type; + tstate->exc_value = *value; + tstate->exc_traceback = *tb; + #endif + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); + PyErr_SetExcInfo(*type, *value, *tb); + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#endif + +/* Import */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level) { + PyObject *empty_list = 0; + PyObject *module = 0; + PyObject *global_dict = 0; + PyObject *empty_dict = 0; + PyObject *list; + #if PY_MAJOR_VERSION < 3 + PyObject *py_import; + py_import = __Pyx_PyObject_GetAttrStr(__pyx_b, __pyx_n_s_import); + if (!py_import) + goto bad; + #endif + if (from_list) + list = from_list; + else { + empty_list = PyList_New(0); + if (!empty_list) + goto bad; + list = empty_list; + } + global_dict = PyModule_GetDict(__pyx_m); + if (!global_dict) + goto bad; + empty_dict = PyDict_New(); + if (!empty_dict) + goto bad; + { + #if PY_MAJOR_VERSION >= 3 + if (level == -1) { + if ((1) && (strchr(__Pyx_MODULE_NAME, '.'))) { + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, 1); + if (!module) { + if (!PyErr_ExceptionMatches(PyExc_ImportError)) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + #endif + if (!module) { + #if PY_MAJOR_VERSION < 3 + PyObject *py_level = PyInt_FromLong(level); + if (!py_level) + goto bad; + module = PyObject_CallFunctionObjArgs(py_import, + name, global_dict, empty_dict, list, py_level, (PyObject *)NULL); + Py_DECREF(py_level); + #else + module = PyImport_ImportModuleLevelObject( + name, global_dict, empty_dict, list, level); + #endif + } + } +bad: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_import); + #endif + Py_XDECREF(empty_list); + Py_XDECREF(empty_dict); + return module; +} + +/* FastTypeChecks */ +#if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = a->tp_base; + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(a, b); +} +#if PY_MAJOR_VERSION == 2 +static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject* exc_type2) { + PyObject *exception, *value, *tb; + int res; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&exception, &value, &tb); + res = exc_type1 ? PyObject_IsSubclass(err, exc_type1) : 0; + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + if (!res) { + res = PyObject_IsSubclass(err, exc_type2); + if (unlikely(res == -1)) { + PyErr_WriteUnraisable(err); + res = 0; + } + } + __Pyx_ErrRestore(exception, value, tb); + return res; +} +#else +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + int res = exc_type1 ? __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type1) : 0; + if (!res) { + res = __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } + return res; +} +#endif +static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + assert(PyExceptionClass_Check(exc_type)); + n = PyTuple_GET_SIZE(tuple); +#if PY_MAJOR_VERSION >= 3 + for (i=0; i= 0 || (x^b) >= 0)) + return PyInt_FromLong(x); + return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + #endif + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + const long b = intval; + long a, x; +#ifdef HAVE_LONG_LONG + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla, llx; +#endif + const digit* digits = ((PyLongObject*)op1)->ob_digit; + const Py_ssize_t size = Py_SIZE(op1); + if (likely(__Pyx_sst_abs(size) <= 1)) { + a = likely(size) ? digits[0] : 0; + if (size == -1) a = -a; + } else { + switch (size) { + case -2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case -4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = -(PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + break; +#ifdef HAVE_LONG_LONG + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + goto long_long; +#endif + } + CYTHON_FALLTHROUGH; + default: return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + } + x = a + b; + return PyLong_FromLong(x); +#ifdef HAVE_LONG_LONG + long_long: + llx = lla + llb; + return PyLong_FromLongLong(llx); +#endif + + + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = PyFloat_AS_DOUBLE(op1); + double result; + PyFPE_START_PROTECT("add", return NULL) + result = ((double)a) + (double)b; + PyFPE_END_PROTECT(result) + return PyFloat_FromDouble(result); + } + return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); +} +#endif + +/* DivInt[long] */ +static CYTHON_INLINE long __Pyx_div_long(long a, long b) { + long q = a / b; + long r = a - q*b; + q -= ((r != 0) & ((r ^ b) < 0)); + return q; +} + +/* ImportFrom */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name) { + PyObject* value = __Pyx_PyObject_GetAttrStr(module, name); + if (unlikely(!value) && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +/* HasAttr */ +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { + PyObject *r; + if (unlikely(!__Pyx_PyBaseString_Check(n))) { + PyErr_SetString(PyExc_TypeError, + "hasattr(): attribute name must be string"); + return -1; + } + r = __Pyx_GetAttr(o, n); + if (unlikely(!r)) { + PyErr_Clear(); + return 0; + } else { + Py_DECREF(r); + return 1; + } +} + +/* PyObject_GenericGetAttrNoDict */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'%.50s' object has no attribute '%U'", + tp->tp_name, attr_name); +#else + "'%.50s' object has no attribute '%.400s'", + tp->tp_name, PyString_AS_STRING(attr_name)); +#endif + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { + PyObject *descr; + PyTypeObject *tp = Py_TYPE(obj); + if (unlikely(!PyString_Check(attr_name))) { + return PyObject_GenericGetAttr(obj, attr_name); + } + assert(!tp->tp_dictoffset); + descr = _PyType_Lookup(tp, attr_name); + if (unlikely(!descr)) { + return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); + } + Py_INCREF(descr); + #if PY_MAJOR_VERSION < 3 + if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) + #endif + { + descrgetfunc f = Py_TYPE(descr)->tp_descr_get; + if (unlikely(f)) { + PyObject *res = f(descr, obj, (PyObject *)tp); + Py_DECREF(descr); + return res; + } + } + return descr; +} +#endif + +/* PyObject_GenericGetAttr */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { + if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { + return PyObject_GenericGetAttr(obj, attr_name); + } + return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); +} +#endif + +/* SetVTable */ +static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); +#else + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#endif + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +/* PyObjectGetAttrStrNoError */ +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +} + +/* SetupReduce */ +static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2); + if (likely(name_attr)) { + ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); + } else { + ret = -1; + } + if (unlikely(ret < 0)) { + PyErr_Clear(); + ret = 0; + } + Py_XDECREF(name_attr); + return ret; +} +static int __Pyx_setup_reduce(PyObject* type_obj) { + int ret = 0; + PyObject *object_reduce = NULL; + PyObject *object_getstate = NULL; + PyObject *object_reduce_ex = NULL; + PyObject *reduce = NULL; + PyObject *reduce_ex = NULL; + PyObject *reduce_cython = NULL; + PyObject *setstate = NULL; + PyObject *setstate_cython = NULL; + PyObject *getstate = NULL; +#if CYTHON_USE_PYTYPE_LOOKUP + getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); +#else + getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); + if (!getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (getstate) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); +#else + object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); + if (!object_getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (object_getstate != getstate) { + goto __PYX_GOOD; + } + } +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#else + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#endif + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; + if (reduce_ex == object_reduce_ex) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#else + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#endif + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; + if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { + reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); + if (likely(reduce_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (reduce == object_reduce || PyErr_Occurred()) { + goto __PYX_BAD; + } + setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); + if (!setstate) PyErr_Clear(); + if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { + setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); + if (likely(setstate_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (!setstate || PyErr_Occurred()) { + goto __PYX_BAD; + } + } + PyType_Modified((PyTypeObject*)type_obj); + } + } + goto __PYX_GOOD; +__PYX_BAD: + if (!PyErr_Occurred()) + PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); + ret = -1; +__PYX_GOOD: +#if !CYTHON_USE_PYTYPE_LOOKUP + Py_XDECREF(object_reduce); + Py_XDECREF(object_reduce_ex); + Py_XDECREF(object_getstate); + Py_XDECREF(getstate); +#endif + Py_XDECREF(reduce); + Py_XDECREF(reduce_ex); + Py_XDECREF(reduce_cython); + Py_XDECREF(setstate); + Py_XDECREF(setstate_cython); + return ret; +} + +/* CLineInTraceback */ +#ifndef CYTHON_CLINE_IN_TRACEBACK +static int __Pyx_CLineForTraceback(CYTHON_UNUSED PyThreadState *tstate, int c_line) { + PyObject *use_cline; + PyObject *ptype, *pvalue, *ptraceback; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict; +#endif + if (unlikely(!__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, *cython_runtime_dict, + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) + } else +#endif + { + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } + } + if (!use_cline) { + c_line = 0; + (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + } + else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache */ +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = NULL; + PyObject *py_funcname = NULL; + #if PY_MAJOR_VERSION < 3 + PyObject *py_srcfile = NULL; + py_srcfile = PyString_FromString(filename); + if (!py_srcfile) goto bad; + #endif + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + funcname = PyUnicode_AsUTF8(py_funcname); + if (!funcname) goto bad; + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + if (!py_funcname) goto bad; + #endif + } + #if PY_MAJOR_VERSION < 3 + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + #else + py_code = PyCode_NewEmpty(filename, funcname, py_line); + #endif + Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline + return py_code; +bad: + Py_XDECREF(py_funcname); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_srcfile); + #endif + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject *ptype, *pvalue, *ptraceback; + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); + } + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) { + /* If the code object creation fails, then we should clear the + fetched exception references and propagate the new exception */ + Py_XDECREF(ptype); + Py_XDECREF(pvalue); + Py_XDECREF(ptraceback); + goto bad; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#if PY_MAJOR_VERSION < 3 +static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { + if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); + if (__Pyx_TypeCheck(obj, __pyx_array_type)) return __pyx_array_getbuffer(obj, view, flags); + if (__Pyx_TypeCheck(obj, __pyx_memoryview_type)) return __pyx_memoryview_getbuffer(obj, view, flags); + PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); + return -1; +} +static void __Pyx_ReleaseBuffer(Py_buffer *view) { + PyObject *obj = view->obj; + if (!obj) return; + if (PyObject_CheckBuffer(obj)) { + PyBuffer_Release(view); + return; + } + if ((0)) {} + view->obj = NULL; + Py_DECREF(obj); +} +#endif + + +/* MemviewSliceIsContig */ +static int +__pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim) +{ + int i, index, step, start; + Py_ssize_t itemsize = mvs.memview->view.itemsize; + if (order == 'F') { + step = 1; + start = 0; + } else { + step = -1; + start = ndim - 1; + } + for (i = 0; i < ndim; i++) { + index = start + step * i; + if (mvs.suboffsets[index] >= 0 || mvs.strides[index] != itemsize) + return 0; + itemsize *= mvs.shape[index]; + } + return 1; +} + +/* OverlappingSlices */ +static void +__pyx_get_array_memory_extents(__Pyx_memviewslice *slice, + void **out_start, void **out_end, + int ndim, size_t itemsize) +{ + char *start, *end; + int i; + start = end = slice->data; + for (i = 0; i < ndim; i++) { + Py_ssize_t stride = slice->strides[i]; + Py_ssize_t extent = slice->shape[i]; + if (extent == 0) { + *out_start = *out_end = start; + return; + } else { + if (stride > 0) + end += stride * (extent - 1); + else + start += stride * (extent - 1); + } + } + *out_start = start; + *out_end = end + itemsize; +} +static int +__pyx_slices_overlap(__Pyx_memviewslice *slice1, + __Pyx_memviewslice *slice2, + int ndim, size_t itemsize) +{ + void *start1, *end1, *start2, *end2; + __pyx_get_array_memory_extents(slice1, &start1, &end1, ndim, itemsize); + __pyx_get_array_memory_extents(slice2, &start2, &end2, ndim, itemsize); + return (start1 < end2) && (start2 < end1); +} + +/* Capsule */ +static CYTHON_INLINE PyObject * +__pyx_capsule_create(void *p, CYTHON_UNUSED const char *sig) +{ + PyObject *cobj; +#if PY_VERSION_HEX >= 0x02070000 + cobj = PyCapsule_New(p, sig, NULL); +#else + cobj = PyCObject_FromVoidPtr(p, NULL); +#endif + return cobj; +} + +/* IsLittleEndian */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) +{ + union { + uint32_t u32; + uint8_t u8[4]; + } S; + S.u32 = 0x01020304; + return S.u8[0] == 4; +} + +/* BufferFormatCheck */ +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type) { + stack[0].field = &ctx->root; + stack[0].parent_offset = 0; + ctx->root.type = type; + ctx->root.name = "buffer dtype"; + ctx->root.offset = 0; + ctx->head = stack; + ctx->head->field = &ctx->root; + ctx->fmt_offset = 0; + ctx->head->parent_offset = 0; + ctx->new_packmode = '@'; + ctx->enc_packmode = '@'; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->is_complex = 0; + ctx->is_valid_array = 0; + ctx->struct_alignment = 0; + while (type->typegroup == 'S') { + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = 0; + type = type->fields->type; + } +} +static int __Pyx_BufFmt_ParseNumber(const char** ts) { + int count; + const char* t = *ts; + if (*t < '0' || *t > '9') { + return -1; + } else { + count = *t++ - '0'; + while (*t >= '0' && *t <= '9') { + count *= 10; + count += *t++ - '0'; + } + } + *ts = t; + return count; +} +static int __Pyx_BufFmt_ExpectNumber(const char **ts) { + int number = __Pyx_BufFmt_ParseNumber(ts); + if (number == -1) + PyErr_Format(PyExc_ValueError,\ + "Does not understand character buffer dtype format string ('%c')", **ts); + return number; +} +static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { + PyErr_Format(PyExc_ValueError, + "Unexpected format string character: '%c'", ch); +} +static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { + switch (ch) { + case '?': return "'bool'"; + case 'c': return "'char'"; + case 'b': return "'signed char'"; + case 'B': return "'unsigned char'"; + case 'h': return "'short'"; + case 'H': return "'unsigned short'"; + case 'i': return "'int'"; + case 'I': return "'unsigned int'"; + case 'l': return "'long'"; + case 'L': return "'unsigned long'"; + case 'q': return "'long long'"; + case 'Q': return "'unsigned long long'"; + case 'f': return (is_complex ? "'complex float'" : "'float'"); + case 'd': return (is_complex ? "'complex double'" : "'double'"); + case 'g': return (is_complex ? "'complex long double'" : "'long double'"); + case 'T': return "a struct"; + case 'O': return "Python object"; + case 'P': return "a pointer"; + case 's': case 'p': return "a string"; + case 0: return "end"; + default: return "unparseable format string"; + } +} +static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return 2; + case 'i': case 'I': case 'l': case 'L': return 4; + case 'q': case 'Q': return 8; + case 'f': return (is_complex ? 8 : 4); + case 'd': return (is_complex ? 16 : 8); + case 'g': { + PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); + return 0; + } + case 'O': case 'P': return sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(short); + case 'i': case 'I': return sizeof(int); + case 'l': case 'L': return sizeof(long); + #ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(PY_LONG_LONG); + #endif + case 'f': return sizeof(float) * (is_complex ? 2 : 1); + case 'd': return sizeof(double) * (is_complex ? 2 : 1); + case 'g': return sizeof(long double) * (is_complex ? 2 : 1); + case 'O': case 'P': return sizeof(void*); + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +typedef struct { char c; short x; } __Pyx_st_short; +typedef struct { char c; int x; } __Pyx_st_int; +typedef struct { char c; long x; } __Pyx_st_long; +typedef struct { char c; float x; } __Pyx_st_float; +typedef struct { char c; double x; } __Pyx_st_double; +typedef struct { char c; long double x; } __Pyx_st_longdouble; +typedef struct { char c; void *x; } __Pyx_st_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_st_float) - sizeof(float); + case 'd': return sizeof(__Pyx_st_double) - sizeof(double); + case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +/* These are for computing the padding at the end of the struct to align + on the first member of the struct. This will probably the same as above, + but we don't have any guarantees. + */ +typedef struct { short x; char c; } __Pyx_pad_short; +typedef struct { int x; char c; } __Pyx_pad_int; +typedef struct { long x; char c; } __Pyx_pad_long; +typedef struct { float x; char c; } __Pyx_pad_float; +typedef struct { double x; char c; } __Pyx_pad_double; +typedef struct { long double x; char c; } __Pyx_pad_longdouble; +typedef struct { void *x; char c; } __Pyx_pad_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); + case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); + case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { + switch (ch) { + case 'c': + return 'H'; + case 'b': case 'h': case 'i': + case 'l': case 'q': case 's': case 'p': + return 'I'; + case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': + return 'U'; + case 'f': case 'd': case 'g': + return (is_complex ? 'C' : 'R'); + case 'O': + return 'O'; + case 'P': + return 'P'; + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { + if (ctx->head == NULL || ctx->head->field == &ctx->root) { + const char* expected; + const char* quote; + if (ctx->head == NULL) { + expected = "end"; + quote = ""; + } else { + expected = ctx->head->field->type->name; + quote = "'"; + } + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected %s%s%s but got %s", + quote, expected, quote, + __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); + } else { + __Pyx_StructField* field = ctx->head->field; + __Pyx_StructField* parent = (ctx->head - 1)->field; + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", + field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), + parent->type->name, field->name); + } +} +static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { + char group; + size_t size, offset, arraysize = 1; + if (ctx->enc_type == 0) return 0; + if (ctx->head->field->type->arraysize[0]) { + int i, ndim = 0; + if (ctx->enc_type == 's' || ctx->enc_type == 'p') { + ctx->is_valid_array = ctx->head->field->type->ndim == 1; + ndim = 1; + if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %zu", + ctx->head->field->type->arraysize[0], ctx->enc_count); + return -1; + } + } + if (!ctx->is_valid_array) { + PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", + ctx->head->field->type->ndim, ndim); + return -1; + } + for (i = 0; i < ctx->head->field->type->ndim; i++) { + arraysize *= ctx->head->field->type->arraysize[i]; + } + ctx->is_valid_array = 0; + ctx->enc_count = 1; + } + group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); + do { + __Pyx_StructField* field = ctx->head->field; + __Pyx_TypeInfo* type = field->type; + if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { + size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); + } else { + size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); + } + if (ctx->enc_packmode == '@') { + size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); + size_t align_mod_offset; + if (align_at == 0) return -1; + align_mod_offset = ctx->fmt_offset % align_at; + if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; + if (ctx->struct_alignment == 0) + ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, + ctx->is_complex); + } + if (type->size != size || type->typegroup != group) { + if (type->typegroup == 'C' && type->fields != NULL) { + size_t parent_offset = ctx->head->parent_offset + field->offset; + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = parent_offset; + continue; + } + if ((type->typegroup == 'H' || group == 'H') && type->size == size) { + } else { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + } + offset = ctx->head->parent_offset + field->offset; + if (ctx->fmt_offset != offset) { + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", + (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); + return -1; + } + ctx->fmt_offset += size; + if (arraysize) + ctx->fmt_offset += (arraysize - 1) * size; + --ctx->enc_count; + while (1) { + if (field == &ctx->root) { + ctx->head = NULL; + if (ctx->enc_count != 0) { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + break; + } + ctx->head->field = ++field; + if (field->type == NULL) { + --ctx->head; + field = ctx->head->field; + continue; + } else if (field->type->typegroup == 'S') { + size_t parent_offset = ctx->head->parent_offset + field->offset; + if (field->type->fields->type == NULL) continue; + field = field->type->fields; + ++ctx->head; + ctx->head->field = field; + ctx->head->parent_offset = parent_offset; + break; + } else { + break; + } + } + } while (ctx->enc_count); + ctx->enc_type = 0; + ctx->is_complex = 0; + return 0; +} +static PyObject * +__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) +{ + const char *ts = *tsp; + int i = 0, number, ndim; + ++ts; + if (ctx->new_count != 1) { + PyErr_SetString(PyExc_ValueError, + "Cannot handle repeated arrays in format string"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ndim = ctx->head->field->type->ndim; + while (*ts && *ts != ')') { + switch (*ts) { + case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; + default: break; + } + number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) + return PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + if (*ts != ',' && *ts != ')') + return PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + if (*ts == ',') ts++; + i++; + } + if (i != ndim) + return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return NULL; + } + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return Py_None; +} +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { + int got_Z = 0; + while (1) { + switch(*ts) { + case 0: + if (ctx->enc_type != 0 && ctx->head == NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (ctx->head != NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + return ts; + case ' ': + case '\r': + case '\n': + ++ts; + break; + case '<': + if (!__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '>': + case '!': + if (__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '=': + case '@': + case '^': + ctx->new_packmode = *ts++; + break; + case 'T': + { + const char* ts_after_sub; + size_t i, struct_count = ctx->new_count; + size_t struct_alignment = ctx->struct_alignment; + ctx->new_count = 1; + ++ts; + if (*ts != '{') { + PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + ctx->enc_count = 0; + ctx->struct_alignment = 0; + ++ts; + ts_after_sub = ts; + for (i = 0; i != struct_count; ++i) { + ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); + if (!ts_after_sub) return NULL; + } + ts = ts_after_sub; + if (struct_alignment) ctx->struct_alignment = struct_alignment; + } + break; + case '}': + { + size_t alignment = ctx->struct_alignment; + ++ts; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + if (alignment && ctx->fmt_offset % alignment) { + ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); + } + } + return ts; + case 'x': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->fmt_offset += ctx->new_count; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->enc_packmode = ctx->new_packmode; + ++ts; + break; + case 'Z': + got_Z = 1; + ++ts; + if (*ts != 'f' && *ts != 'd' && *ts != 'g') { + __Pyx_BufFmt_RaiseUnexpectedChar('Z'); + return NULL; + } + CYTHON_FALLTHROUGH; + case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'l': case 'L': case 'q': case 'Q': + case 'f': case 'd': case 'g': + case 'O': case 'p': + if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && + (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { + ctx->enc_count += ctx->new_count; + ctx->new_count = 1; + got_Z = 0; + ++ts; + break; + } + CYTHON_FALLTHROUGH; + case 's': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_count = ctx->new_count; + ctx->enc_packmode = ctx->new_packmode; + ctx->enc_type = *ts; + ctx->is_complex = got_Z; + ++ts; + ctx->new_count = 1; + got_Z = 0; + break; + case ':': + ++ts; + while(*ts != ':') ++ts; + ++ts; + break; + case '(': + if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; + } + } + } +} + +/* TypeInfoCompare */ + static int +__pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b) +{ + int i; + if (!a || !b) + return 0; + if (a == b) + return 1; + if (a->size != b->size || a->typegroup != b->typegroup || + a->is_unsigned != b->is_unsigned || a->ndim != b->ndim) { + if (a->typegroup == 'H' || b->typegroup == 'H') { + return a->size == b->size; + } else { + return 0; + } + } + if (a->ndim) { + for (i = 0; i < a->ndim; i++) + if (a->arraysize[i] != b->arraysize[i]) + return 0; + } + if (a->typegroup == 'S') { + if (a->flags != b->flags) + return 0; + if (a->fields || b->fields) { + if (!(a->fields && b->fields)) + return 0; + for (i = 0; a->fields[i].type && b->fields[i].type; i++) { + __Pyx_StructField *field_a = a->fields + i; + __Pyx_StructField *field_b = b->fields + i; + if (field_a->offset != field_b->offset || + !__pyx_typeinfo_cmp(field_a->type, field_b->type)) + return 0; + } + return !a->fields[i].type && !b->fields[i].type; + } + } + return 1; +} + +/* MemviewSliceValidateAndInit */ + static int +__pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec) +{ + if (buf->shape[dim] <= 1) + return 1; + if (buf->strides) { + if (spec & __Pyx_MEMVIEW_CONTIG) { + if (spec & (__Pyx_MEMVIEW_PTR|__Pyx_MEMVIEW_FULL)) { + if (unlikely(buf->strides[dim] != sizeof(void *))) { + PyErr_Format(PyExc_ValueError, + "Buffer is not indirectly contiguous " + "in dimension %d.", dim); + goto fail; + } + } else if (unlikely(buf->strides[dim] != buf->itemsize)) { + PyErr_SetString(PyExc_ValueError, + "Buffer and memoryview are not contiguous " + "in the same dimension."); + goto fail; + } + } + if (spec & __Pyx_MEMVIEW_FOLLOW) { + Py_ssize_t stride = buf->strides[dim]; + if (stride < 0) + stride = -stride; + if (unlikely(stride < buf->itemsize)) { + PyErr_SetString(PyExc_ValueError, + "Buffer and memoryview are not contiguous " + "in the same dimension."); + goto fail; + } + } + } else { + if (unlikely(spec & __Pyx_MEMVIEW_CONTIG && dim != ndim - 1)) { + PyErr_Format(PyExc_ValueError, + "C-contiguous buffer is not contiguous in " + "dimension %d", dim); + goto fail; + } else if (unlikely(spec & (__Pyx_MEMVIEW_PTR))) { + PyErr_Format(PyExc_ValueError, + "C-contiguous buffer is not indirect in " + "dimension %d", dim); + goto fail; + } else if (unlikely(buf->suboffsets)) { + PyErr_SetString(PyExc_ValueError, + "Buffer exposes suboffsets but no strides"); + goto fail; + } + } + return 1; +fail: + return 0; +} +static int +__pyx_check_suboffsets(Py_buffer *buf, int dim, CYTHON_UNUSED int ndim, int spec) +{ + if (spec & __Pyx_MEMVIEW_DIRECT) { + if (unlikely(buf->suboffsets && buf->suboffsets[dim] >= 0)) { + PyErr_Format(PyExc_ValueError, + "Buffer not compatible with direct access " + "in dimension %d.", dim); + goto fail; + } + } + if (spec & __Pyx_MEMVIEW_PTR) { + if (unlikely(!buf->suboffsets || (buf->suboffsets[dim] < 0))) { + PyErr_Format(PyExc_ValueError, + "Buffer is not indirectly accessible " + "in dimension %d.", dim); + goto fail; + } + } + return 1; +fail: + return 0; +} +static int +__pyx_verify_contig(Py_buffer *buf, int ndim, int c_or_f_flag) +{ + int i; + if (c_or_f_flag & __Pyx_IS_F_CONTIG) { + Py_ssize_t stride = 1; + for (i = 0; i < ndim; i++) { + if (unlikely(stride * buf->itemsize != buf->strides[i] && buf->shape[i] > 1)) { + PyErr_SetString(PyExc_ValueError, + "Buffer not fortran contiguous."); + goto fail; + } + stride = stride * buf->shape[i]; + } + } else if (c_or_f_flag & __Pyx_IS_C_CONTIG) { + Py_ssize_t stride = 1; + for (i = ndim - 1; i >- 1; i--) { + if (unlikely(stride * buf->itemsize != buf->strides[i] && buf->shape[i] > 1)) { + PyErr_SetString(PyExc_ValueError, + "Buffer not C contiguous."); + goto fail; + } + stride = stride * buf->shape[i]; + } + } + return 1; +fail: + return 0; +} +static int __Pyx_ValidateAndInit_memviewslice( + int *axes_specs, + int c_or_f_flag, + int buf_flags, + int ndim, + __Pyx_TypeInfo *dtype, + __Pyx_BufFmt_StackElem stack[], + __Pyx_memviewslice *memviewslice, + PyObject *original_obj) +{ + struct __pyx_memoryview_obj *memview, *new_memview; + __Pyx_RefNannyDeclarations + Py_buffer *buf; + int i, spec = 0, retval = -1; + __Pyx_BufFmt_Context ctx; + int from_memoryview = __pyx_memoryview_check(original_obj); + __Pyx_RefNannySetupContext("ValidateAndInit_memviewslice", 0); + if (from_memoryview && __pyx_typeinfo_cmp(dtype, ((struct __pyx_memoryview_obj *) + original_obj)->typeinfo)) { + memview = (struct __pyx_memoryview_obj *) original_obj; + new_memview = NULL; + } else { + memview = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( + original_obj, buf_flags, 0, dtype); + new_memview = memview; + if (unlikely(!memview)) + goto fail; + } + buf = &memview->view; + if (unlikely(buf->ndim != ndim)) { + PyErr_Format(PyExc_ValueError, + "Buffer has wrong number of dimensions (expected %d, got %d)", + ndim, buf->ndim); + goto fail; + } + if (new_memview) { + __Pyx_BufFmt_Init(&ctx, stack, dtype); + if (unlikely(!__Pyx_BufFmt_CheckString(&ctx, buf->format))) goto fail; + } + if (unlikely((unsigned) buf->itemsize != dtype->size)) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "u byte%s) " + "does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "u byte%s)", + buf->itemsize, + (buf->itemsize > 1) ? "s" : "", + dtype->name, + dtype->size, + (dtype->size > 1) ? "s" : ""); + goto fail; + } + if (buf->len > 0) { + for (i = 0; i < ndim; i++) { + spec = axes_specs[i]; + if (unlikely(!__pyx_check_strides(buf, i, ndim, spec))) + goto fail; + if (unlikely(!__pyx_check_suboffsets(buf, i, ndim, spec))) + goto fail; + } + if (unlikely(buf->strides && !__pyx_verify_contig(buf, ndim, c_or_f_flag))) + goto fail; + } + if (unlikely(__Pyx_init_memviewslice(memview, ndim, memviewslice, + new_memview != NULL) == -1)) { + goto fail; + } + retval = 0; + goto no_fail; +fail: + Py_XDECREF(new_memview); + retval = -1; +no_fail: + __Pyx_RefNannyFinishContext(); + return retval; +} + +/* ObjectToMemviewSlice */ + static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dsds_nn_int32_t(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_STRIDED), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_STRIDED) }; + int retcode; + if (obj == Py_None) { + result.memview = (struct __pyx_memoryview_obj *) Py_None; + return result; + } + retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, 0, + PyBUF_RECORDS_RO | writable_flag, 2, + &__Pyx_TypeInfo_nn_int32_t, stack, + &result, obj); + if (unlikely(retcode == -1)) + goto __pyx_fail; + return result; +__pyx_fail: + result.memview = NULL; + result.data = NULL; + return result; +} + +/* CIntFromPyVerify */ + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* MemviewSliceCopyTemplate */ + static __Pyx_memviewslice +__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, + const char *mode, int ndim, + size_t sizeof_dtype, int contig_flag, + int dtype_is_object) +{ + __Pyx_RefNannyDeclarations + int i; + __Pyx_memviewslice new_mvs = { 0, 0, { 0 }, { 0 }, { 0 } }; + struct __pyx_memoryview_obj *from_memview = from_mvs->memview; + Py_buffer *buf = &from_memview->view; + PyObject *shape_tuple = NULL; + PyObject *temp_int = NULL; + struct __pyx_array_obj *array_obj = NULL; + struct __pyx_memoryview_obj *memview_obj = NULL; + __Pyx_RefNannySetupContext("__pyx_memoryview_copy_new_contig", 0); + for (i = 0; i < ndim; i++) { + if (unlikely(from_mvs->suboffsets[i] >= 0)) { + PyErr_Format(PyExc_ValueError, "Cannot copy memoryview slice with " + "indirect dimensions (axis %d)", i); + goto fail; + } + } + shape_tuple = PyTuple_New(ndim); + if (unlikely(!shape_tuple)) { + goto fail; + } + __Pyx_GOTREF(shape_tuple); + for(i = 0; i < ndim; i++) { + temp_int = PyInt_FromSsize_t(from_mvs->shape[i]); + if(unlikely(!temp_int)) { + goto fail; + } else { + PyTuple_SET_ITEM(shape_tuple, i, temp_int); + temp_int = NULL; + } + } + array_obj = __pyx_array_new(shape_tuple, sizeof_dtype, buf->format, (char *) mode, NULL); + if (unlikely(!array_obj)) { + goto fail; + } + __Pyx_GOTREF(array_obj); + memview_obj = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( + (PyObject *) array_obj, contig_flag, + dtype_is_object, + from_mvs->memview->typeinfo); + if (unlikely(!memview_obj)) + goto fail; + if (unlikely(__Pyx_init_memviewslice(memview_obj, ndim, &new_mvs, 1) < 0)) + goto fail; + if (unlikely(__pyx_memoryview_copy_contents(*from_mvs, new_mvs, ndim, ndim, + dtype_is_object) < 0)) + goto fail; + goto no_fail; +fail: + __Pyx_XDECREF(new_mvs.memview); + new_mvs.memview = NULL; + new_mvs.data = NULL; +no_fail: + __Pyx_XDECREF(shape_tuple); + __Pyx_XDECREF(temp_int); + __Pyx_XDECREF(array_obj); + __Pyx_RefNannyFinishContext(); + return new_mvs; +} + +/* CIntFromPy */ + static CYTHON_INLINE int32_t __Pyx_PyInt_As_int32_t(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int32_t neg_one = (int32_t) -1, const_zero = (int32_t) 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(int32_t) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int32_t, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int32_t) 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 (int32_t) 0; + case 1: __PYX_VERIFY_RETURN_INT(int32_t, digit, digits[0]) + case 2: + if (8 * sizeof(int32_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) >= 2 * PyLong_SHIFT) { + return (int32_t) (((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int32_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) >= 3 * PyLong_SHIFT) { + return (int32_t) (((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int32_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, 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(int32_t) >= 4 * PyLong_SHIFT) { + return (int32_t) (((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)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 (int32_t) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int32_t) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int32_t, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int32_t) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int32_t, 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 (int32_t) 0; + case -1: __PYX_VERIFY_RETURN_INT(int32_t, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int32_t, digit, +digits[0]) + case -2: + if (8 * sizeof(int32_t) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT) { + return (int32_t) (((int32_t)-1)*(((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int32_t) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT) { + return (int32_t) ((((((int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int32_t) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT) { + return (int32_t) (((int32_t)-1)*(((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int32_t) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT) { + return (int32_t) ((((((((int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int32_t) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, 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(int32_t) - 1 > 4 * PyLong_SHIFT) { + return (int32_t) (((int32_t)-1)*(((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int32_t) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int32_t, 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(int32_t) - 1 > 4 * PyLong_SHIFT) { + return (int32_t) ((((((((((int32_t)digits[3]) << PyLong_SHIFT) | (int32_t)digits[2]) << PyLong_SHIFT) | (int32_t)digits[1]) << PyLong_SHIFT) | (int32_t)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int32_t) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int32_t, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int32_t) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int32_t, 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 + int32_t 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 (int32_t) -1; + } + } else { + int32_t val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int32_t) -1; + val = __Pyx_PyInt_As_int32_t(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int32_t"); + return (int32_t) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int32_t"); + return (int32_t) -1; +} + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int32_t(int32_t value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int32_t neg_one = (int32_t) -1, const_zero = (int32_t) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int32_t) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int32_t) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int32_t) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int32_t) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int32_t) <= 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(int32_t), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const char neg_one = (char) -1, const_zero = (char) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(char) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(char, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (char) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (char) 0; + case 1: __PYX_VERIFY_RETURN_INT(char, digit, digits[0]) + case 2: + if (8 * sizeof(char) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 2 * PyLong_SHIFT) { + return (char) (((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(char) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 3 * PyLong_SHIFT) { + return (char) (((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(char) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 4 * PyLong_SHIFT) { + return (char) (((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (char) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(char) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(char, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(char) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (char) 0; + case -1: __PYX_VERIFY_RETURN_INT(char, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(char, digit, +digits[0]) + case -2: + if (8 * sizeof(char) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(char) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + return (char) ((((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(char) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + return (char) ((((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(char) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) { + return (char) ((((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + } +#endif + if (sizeof(char) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(char, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(char) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(char, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + char val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (char) -1; + } + } else { + char val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (char) -1; + val = __Pyx_PyInt_As_char(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to char"); + return (char) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to char"); + return (char) -1; +} + +/* CheckBinaryVersion */ + static int __Pyx_check_binary_version(void) { + char ctversion[5]; + int same=1, i, found_dot; + const char* rt_from_call = Py_GetVersion(); + PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + found_dot = 0; + for (i = 0; i < 4; i++) { + if (!ctversion[i]) { + same = (rt_from_call[i] < '0' || rt_from_call[i] > '9'); + break; + } + if (rt_from_call[i] != ctversion[i]) { + same = 0; + break; + } + } + if (!same) { + char rtversion[5] = {'\0'}; + char message[200]; + for (i=0; i<4; ++i) { + if (rt_from_call[i] == '.') { + if (found_dot) break; + found_dot = 1; + } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { + break; + } + rtversion[i] = rt_from_call[i]; + } + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +/* InitStrings */ + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + if (PyObject_Hash(*t->p) == -1) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#if !CYTHON_PEP393_ENABLED +static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +} +#else +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (likely(PyUnicode_IS_ASCII(o))) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +} +#endif +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { + int retval; + if (unlikely(!x)) return -1; + retval = __Pyx_PyObject_IsTrue(x); + Py_DECREF(x); + return retval; +} +static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { +#if PY_MAJOR_VERSION >= 3 + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type %.200s). " + "The ability to return an instance of a strict subclass of int " + "is deprecated, and may be removed in a future version of Python.", + Py_TYPE(result)->tp_name)) { + Py_DECREF(result); + return NULL; + } + return result; + } +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + type_name, type_name, Py_TYPE(result)->tp_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x) || PyLong_Check(x))) +#else + if (likely(PyLong_Check(x))) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = m->nb_int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = m->nb_long(x); + } + #else + if (likely(m && m->nb_int)) { + name = "int"; + res = m->nb_int(x); + } + #endif +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Int(x); + } +#endif + if (likely(res)) { +#if PY_MAJOR_VERSION < 3 + if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { +#else + if (unlikely(!PyLong_CheckExact(res))) { +#endif + return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(b); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { + if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { + return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); +#if PY_MAJOR_VERSION < 3 + } else if (likely(PyInt_CheckExact(o))) { + return PyInt_AS_LONG(o); +#endif + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyInt_AsLong(x); + Py_DECREF(x); + return ival; + } +} +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/zoo/board_games/tictactoe/envs/legal_actions_cython.cpp b/zoo/board_games/tictactoe/envs/legal_actions_cython.cpp new file mode 100644 index 000000000..c186d29df --- /dev/null +++ b/zoo/board_games/tictactoe/envs/legal_actions_cython.cpp @@ -0,0 +1,21154 @@ +/* Generated by Cython 0.29.34 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [], + "include_dirs": [ + "/private/var/folders/r5/znmp_3cn0_b41yvr2tvld9ys0qypks/T/pip-build-env-6l8r0sjs/overlay/lib/python3.8/site-packages/numpy/core/include" + ], + "language": "c++", + "name": "zoo.board_games.tictactoe.envs.legal_actions_cython", + "sources": [ + "/Users/puyuan/code/LightZero/zoo/board_games/tictactoe/envs/legal_actions_cython.pyx" + ] + }, + "module_name": "zoo.board_games.tictactoe.envs.legal_actions_cython" +} +END: Cython Metadata */ + +#ifndef PY_SSIZE_T_CLEAN +#define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000) + #error Cython requires Python 2.6+ or Python 3.3+. +#else +#define CYTHON_ABI "0_29_34" +#define CYTHON_HEX_VERSION 0x001D22F0 +#define CYTHON_FUTURE_DIVISION 1 +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#define __PYX_COMMA , +#ifndef HAVE_LONG_LONG + #if PY_VERSION_HEX >= 0x02070000 + #define HAVE_LONG_LONG + #endif +#endif +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#ifdef PYPY_VERSION + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #if PY_VERSION_HEX < 0x03050000 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif +#elif defined(PYSTON_VERSION) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_NOGIL 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif +#elif defined(PY_NOGIL) + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_NOGIL 1 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #ifndef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_PYSTON 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_NOGIL 0 + #ifndef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #elif !defined(CYTHON_USE_PYTYPE_LOOKUP) + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif + #if PY_MAJOR_VERSION < 3 + #undef CYTHON_USE_ASYNC_SLOTS + #define CYTHON_USE_ASYNC_SLOTS 0 + #elif !defined(CYTHON_USE_ASYNC_SLOTS) + #define CYTHON_USE_ASYNC_SLOTS 1 + #endif + #if PY_VERSION_HEX < 0x02070000 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLONG_INTERNALS) + #define CYTHON_USE_PYLONG_INTERNALS (PY_VERSION_HEX < 0x030C00A5) + #endif + #ifndef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if PY_VERSION_HEX < 0x030300F0 || PY_VERSION_HEX >= 0x030B00A2 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #if PY_VERSION_HEX >= 0x030B00A4 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #elif !defined(CYTHON_FAST_THREAD_STATE) + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL (PY_VERSION_HEX < 0x030A0000) + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT (PY_VERSION_HEX >= 0x03050000) + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1) + #endif + #ifndef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS ((PY_VERSION_HEX >= 0x030600B1) && (PY_VERSION_HEX < 0x030C00A5)) + #endif + #if PY_VERSION_HEX >= 0x030B00A4 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #elif !defined(CYTHON_USE_EXC_INFO_STACK) + #define CYTHON_USE_EXC_INFO_STACK (PY_VERSION_HEX >= 0x030700A3) + #endif + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif +#endif +#if !defined(CYTHON_FAST_PYCCALL) +#define CYTHON_FAST_PYCCALL (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1) +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_MAJOR_VERSION < 3 + #include "longintrepr.h" + #endif + #undef SHIFT + #undef BASE + #undef MASK + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + #endif +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_MAYBE_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) +#ifdef _MSC_VER + #ifndef _MSC_STDINT_H_ + #if _MSC_VER < 1300 + typedef unsigned char uint8_t; + typedef unsigned int uint32_t; + #else + typedef unsigned __int8 uint8_t; + typedef unsigned __int32 uint32_t; + #endif + #endif +#else + #include +#endif +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) && __cplusplus >= 201103L + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #elif __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + #if defined(__clang__ ) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif + +#ifndef __cplusplus + #error "Cython files generated with the C++ option must be compiled with a C++ compiler." +#endif +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #else + #define CYTHON_INLINE inline + #endif +#endif +template +void __Pyx_call_destructor(T& x) { + x.~T(); +} +template +class __Pyx_FakeReference { + public: + __Pyx_FakeReference() : ptr(NULL) { } + __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { } + T *operator->() { return ptr; } + T *operator&() { return ptr; } + operator T&() { return *ptr; } + template bool operator ==(U other) { return *ptr == other; } + template bool operator !=(U other) { return *ptr != other; } + private: + T *ptr; +}; + +#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag) + #define Py_OptimizeFlag 0 +#endif +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#if PY_MAJOR_VERSION < 3 + #define __Pyx_BUILTIN_MODULE_NAME "__builtin__" + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #define __Pyx_DefaultClassType PyClass_Type +#else + #define __Pyx_BUILTIN_MODULE_NAME "builtins" + #define __Pyx_DefaultClassType PyType_Type +#if PY_VERSION_HEX >= 0x030B00A1 + static CYTHON_INLINE PyCodeObject* __Pyx_PyCode_New(int a, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyObject *kwds=NULL, *argcount=NULL, *posonlyargcount=NULL, *kwonlyargcount=NULL; + PyObject *nlocals=NULL, *stacksize=NULL, *flags=NULL, *replace=NULL, *call_result=NULL, *empty=NULL; + const char *fn_cstr=NULL; + const char *name_cstr=NULL; + PyCodeObject* co=NULL; + PyObject *type, *value, *traceback; + PyErr_Fetch(&type, &value, &traceback); + if (!(kwds=PyDict_New())) goto end; + if (!(argcount=PyLong_FromLong(a))) goto end; + if (PyDict_SetItemString(kwds, "co_argcount", argcount) != 0) goto end; + if (!(posonlyargcount=PyLong_FromLong(0))) goto end; + if (PyDict_SetItemString(kwds, "co_posonlyargcount", posonlyargcount) != 0) goto end; + if (!(kwonlyargcount=PyLong_FromLong(k))) goto end; + if (PyDict_SetItemString(kwds, "co_kwonlyargcount", kwonlyargcount) != 0) goto end; + if (!(nlocals=PyLong_FromLong(l))) goto end; + if (PyDict_SetItemString(kwds, "co_nlocals", nlocals) != 0) goto end; + if (!(stacksize=PyLong_FromLong(s))) goto end; + if (PyDict_SetItemString(kwds, "co_stacksize", stacksize) != 0) goto end; + if (!(flags=PyLong_FromLong(f))) goto end; + if (PyDict_SetItemString(kwds, "co_flags", flags) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_code", code) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_consts", c) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_names", n) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_varnames", v) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_freevars", fv) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_cellvars", cell) != 0) goto end; + if (PyDict_SetItemString(kwds, "co_linetable", lnos) != 0) goto end; + if (!(fn_cstr=PyUnicode_AsUTF8AndSize(fn, NULL))) goto end; + if (!(name_cstr=PyUnicode_AsUTF8AndSize(name, NULL))) goto end; + if (!(co = PyCode_NewEmpty(fn_cstr, name_cstr, fline))) goto end; + if (!(replace = PyObject_GetAttrString((PyObject*)co, "replace"))) goto cleanup_code_too; + if (!(empty = PyTuple_New(0))) goto cleanup_code_too; // unfortunately __pyx_empty_tuple isn't available here + if (!(call_result = PyObject_Call(replace, empty, kwds))) goto cleanup_code_too; + Py_XDECREF((PyObject*)co); + co = (PyCodeObject*)call_result; + call_result = NULL; + if (0) { + cleanup_code_too: + Py_XDECREF((PyObject*)co); + co = NULL; + } + end: + Py_XDECREF(kwds); + Py_XDECREF(argcount); + Py_XDECREF(posonlyargcount); + Py_XDECREF(kwonlyargcount); + Py_XDECREF(nlocals); + Py_XDECREF(stacksize); + Py_XDECREF(replace); + Py_XDECREF(call_result); + Py_XDECREF(empty); + if (type) { + PyErr_Restore(type, value, traceback); + } + return co; + } +#else + #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) +#endif + #define __Pyx_DefaultClassType PyType_Type +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef METH_STACKLESS + #define METH_STACKLESS 0 +#endif +#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL) + #ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #define __Pyx_PyCFunctionFast _PyCFunctionFast + #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords +#endif +#if CYTHON_FAST_PYCCALL +#define __Pyx_PyFastCFunction_Check(func)\ + ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))))) +#else +#define __Pyx_PyFastCFunction_Check(func) 0 +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030400A1 + #define PyMem_RawMalloc(n) PyMem_Malloc(n) + #define PyMem_RawRealloc(p, n) PyMem_Realloc(p, n) + #define PyMem_RawFree(p) PyMem_Free(p) +#endif +#if CYTHON_COMPILING_IN_PYSTON + #define __Pyx_PyCode_HasFreeVars(co) PyCode_HasFreeVars(co) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x03060000 + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#elif PY_VERSION_HEX >= 0x03000000 + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_Current +#endif +#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT) +#include "pythread.h" +#define Py_tss_NEEDS_INIT 0 +typedef int Py_tss_t; +static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) { + *key = PyThread_create_key(); + return 0; +} +static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) { + Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t)); + *key = Py_tss_NEEDS_INIT; + return key; +} +static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) { + PyObject_Free(key); +} +static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) { + return *key != Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) { + PyThread_delete_key(*key); + *key = Py_tss_NEEDS_INIT; +} +static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) { + return PyThread_set_key_value(*key, value); +} +static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) { + return PyThread_get_key_value(*key); +} +#endif +#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif +#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION + #define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#else + #define __Pyx_PyNumber_Divide(x,y) PyNumber_Divide(x,y) + #define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceDivide(x,y) +#endif +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStr(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +#else +#define __Pyx_PyDict_GetItemStr(dict, name) PyDict_GetItem(dict, name) +#endif +#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND) + #define CYTHON_PEP393_ENABLED 1 + #if 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_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 PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #else + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif + #endif +#else + #define CYTHON_PEP393_ENABLED 0 + #define PyUnicode_1BYTE_KIND 1 + #define PyUnicode_2BYTE_KIND 2 + #define PyUnicode_4BYTE_KIND 4 + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_GET_LENGTH(u) PyUnicode_GET_SIZE(u) + #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i])) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111) + #define __Pyx_PyUnicode_KIND(u) (sizeof(Py_UNICODE)) + #define __Pyx_PyUnicode_DATA(u) ((void*)PyUnicode_AS_UNICODE(u)) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i])) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) (((void)(k)), ((Py_UNICODE*)d)[i] = ch) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_SIZE(u)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) +#endif +#define __Pyx_PyString_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyString_Check(b) && !PyString_CheckExact(b)))) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b)) +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyString_Format(a, b) PyUnicode_Format(a, b) +#else + #define __Pyx_PyString_Format(a, b) PyString_Format(a, b) +#endif +#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII) + #define PyObject_ASCII(o) PyObject_Repr(o) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBaseString_Type PyUnicode_Type + #define PyStringObject PyUnicodeObject + #define PyString_Type PyUnicode_Type + #define PyString_Check PyUnicode_Check + #define PyString_CheckExact PyUnicode_CheckExact +#ifndef PyObject_Unicode + #define PyObject_Unicode PyObject_Str +#endif +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj) + #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj) +#else + #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj)) + #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj)) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) (Py_TYPE(obj) == &PySet_Type) +#endif +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) +#else + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyIntObject PyLongObject + #define PyInt_Type PyLong_Type + #define PyInt_Check(op) PyLong_Check(op) + #define PyInt_CheckExact(op) PyLong_CheckExact(op) + #define PyInt_FromString PyLong_FromString + #define PyInt_FromUnicode PyLong_FromUnicode + #define PyInt_FromLong PyLong_FromLong + #define PyInt_FromSize_t PyLong_FromSize_t + #define PyInt_FromSsize_t PyLong_FromSsize_t + #define PyInt_AsLong PyLong_AsLong + #define PyInt_AS_LONG PyLong_AS_LONG + #define PyInt_AsSsize_t PyLong_AsSsize_t + #define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask + #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask + #define PyNumber_Int PyNumber_Long +#endif +#if PY_MAJOR_VERSION >= 3 + #define PyBoolObject PyLongObject +#endif +#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY + #ifndef PyUnicode_InternFromString + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) + #endif +#endif +#if PY_VERSION_HEX < 0x030200A4 + typedef long Py_hash_t; + #define __Pyx_PyInt_FromHash_t PyInt_FromLong + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsHash_t +#else + #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t + #define __Pyx_PyInt_AsHash_t __Pyx_PyIndex_AsSsize_t +#endif +#if PY_MAJOR_VERSION >= 3 + #define __Pyx_PyMethod_New(func, self, klass) ((self) ? ((void)(klass), PyMethod_New(func, self)) : __Pyx_NewRef(func)) +#else + #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass) +#endif +#if CYTHON_USE_ASYNC_SLOTS + #if PY_VERSION_HEX >= 0x030500B1 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods + #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async) + #else + #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved)) + #endif +#else + #define __Pyx_PyType_AsAsync(obj) NULL +#endif +#ifndef __Pyx_PyAsyncMethodsStruct + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + } __Pyx_PyAsyncMethodsStruct; +#endif + +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #if !defined(_USE_MATH_DEFINES) + #define _USE_MATH_DEFINES + #endif +#endif +#include +#ifdef NAN +#define __PYX_NAN() ((float) NAN) +#else +static CYTHON_INLINE float __PYX_NAN() { + float value; + memset(&value, 0xFF, sizeof(value)); + return value; +} +#endif +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + +#define __PYX_MARK_ERR_POS(f_index, lineno) \ + { __pyx_filename = __pyx_f[f_index]; (void)__pyx_filename; __pyx_lineno = lineno; (void)__pyx_lineno; __pyx_clineno = __LINE__; (void)__pyx_clineno; } +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifndef __PYX_EXTERN_C + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__zoo__board_games__tictactoe__envs__legal_actions_cython +#define __PYX_HAVE_API__zoo__board_games__tictactoe__envs__legal_actions_cython +/* Early includes */ +#include +#include "pythread.h" +#include +#include +#include +#include "pystate.h" +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding; + const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry; + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT (PY_MAJOR_VERSION >= 3 && __PYX_DEFAULT_STRING_ENCODING_IS_UTF8) +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { + return (size_t) i < (size_t) limit; +} +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) + #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s)) +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if PY_MAJOR_VERSION < 3 + #define __Pyx_PyStr_FromString __Pyx_PyBytes_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#else + #define __Pyx_PyStr_FromString __Pyx_PyUnicode_FromString + #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize +#endif +#define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) +#define __Pyx_PyObject_AsWritableString(s) ((char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyStr_FromCString(s) __Pyx_PyStr_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) { + const Py_UNICODE *u_end = u; + while (*u_end++) ; + return (size_t)(u_end - u - 1); +} +#define __Pyx_PyUnicode_FromUnicode(u) PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u)) +#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj) +#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None) +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x); +#define __Pyx_PySequence_Tuple(obj)\ + (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t); +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); +#if CYTHON_ASSUME_SAFE_MACROS +#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#else +#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#endif +#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x)) +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#else +#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x)) +#endif +#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x)) +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII +static int __Pyx_sys_getdefaultencoding_not_ascii; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + PyObject* ascii_chars_u = NULL; + PyObject* ascii_chars_b = NULL; + const char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + if (strcmp(default_encoding_c, "ascii") == 0) { + __Pyx_sys_getdefaultencoding_not_ascii = 0; + } else { + char ascii_chars[128]; + int c; + for (c = 0; c < 128; c++) { + ascii_chars[c] = c; + } + __Pyx_sys_getdefaultencoding_not_ascii = 1; + ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL); + if (!ascii_chars_u) goto bad; + ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL); + if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) { + PyErr_Format( + PyExc_ValueError, + "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.", + default_encoding_c); + goto bad; + } + Py_DECREF(ascii_chars_u); + Py_DECREF(ascii_chars_b); + } + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + Py_XDECREF(ascii_chars_u); + Py_XDECREF(ascii_chars_b); + return -1; +} +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3 +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#else +#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +static char* __PYX_DEFAULT_STRING_ENCODING; +static int __Pyx_init_sys_getdefaultencoding_params(void) { + PyObject* sys; + PyObject* default_encoding = NULL; + char* default_encoding_c; + sys = PyImport_ImportModule("sys"); + if (!sys) goto bad; + default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL); + Py_DECREF(sys); + if (!default_encoding) goto bad; + default_encoding_c = PyBytes_AsString(default_encoding); + if (!default_encoding_c) goto bad; + __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1); + if (!__PYX_DEFAULT_STRING_ENCODING) goto bad; + strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c); + Py_DECREF(default_encoding); + return 0; +bad: + Py_XDECREF(default_encoding); + return -1; +} +#endif +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } + +static PyObject *__pyx_m = NULL; +static PyObject *__pyx_d; +static PyObject *__pyx_b; +static PyObject *__pyx_cython_runtime = NULL; +static PyObject *__pyx_empty_tuple; +static PyObject *__pyx_empty_bytes; +static PyObject *__pyx_empty_unicode; +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * __pyx_cfilenm= __FILE__; +static const char *__pyx_filename; + + +static const char *__pyx_f[] = { + "zoo/board_games/tictactoe/envs/legal_actions_cython.pyx", + "stringsource", +}; +/* MemviewSliceStruct.proto */ +struct __pyx_memoryview_obj; +typedef struct { + struct __pyx_memoryview_obj *memview; + char *data; + Py_ssize_t shape[8]; + Py_ssize_t strides[8]; + Py_ssize_t suboffsets[8]; +} __Pyx_memviewslice; +#define __Pyx_MemoryView_Len(m) (m.shape[0]) + +/* Atomics.proto */ +#include +#ifndef CYTHON_ATOMICS + #define CYTHON_ATOMICS 1 +#endif +#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS +#define __pyx_atomic_int_type int +#if CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\ + (__GNUC_MINOR__ > 1 ||\ + (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) + #define __pyx_atomic_incr_aligned(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_decr_aligned(value) __sync_fetch_and_sub(value, 1) + #ifdef __PYX_DEBUG_ATOMICS + #warning "Using GNU atomics" + #endif +#elif CYTHON_ATOMICS && defined(_MSC_VER) && CYTHON_COMPILING_IN_NOGIL + #include + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type long + #pragma intrinsic (_InterlockedExchangeAdd) + #define __pyx_atomic_incr_aligned(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_decr_aligned(value) _InterlockedExchangeAdd(value, -1) + #ifdef __PYX_DEBUG_ATOMICS + #pragma message ("Using MSVC atomics") + #endif +#else + #undef CYTHON_ATOMICS + #define CYTHON_ATOMICS 0 + #ifdef __PYX_DEBUG_ATOMICS + #warning "Not using atomics" + #endif +#endif +typedef volatile __pyx_atomic_int_type __pyx_atomic_int; +#if CYTHON_ATOMICS + #define __pyx_add_acquisition_count(memview)\ + __pyx_atomic_incr_aligned(__pyx_get_slice_count_pointer(memview)) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_atomic_decr_aligned(__pyx_get_slice_count_pointer(memview)) +#else + #define __pyx_add_acquisition_count(memview)\ + __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) +#endif + +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + +/* NoFastGil.proto */ +#define __Pyx_PyGILState_Ensure PyGILState_Ensure +#define __Pyx_PyGILState_Release PyGILState_Release +#define __Pyx_FastGIL_Remember() +#define __Pyx_FastGIL_Forget() +#define __Pyx_FastGilFuncInit() + +/* BufferFormatStructs.proto */ +#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; + +/* "View.MemoryView":106 + * + * @cname("__pyx_array") + * cdef class array: # <<<<<<<<<<<<<< + * + * cdef: + */ +struct __pyx_array_obj { + PyObject_HEAD + struct __pyx_vtabstruct_array *__pyx_vtab; + char *data; + Py_ssize_t len; + char *format; + int ndim; + Py_ssize_t *_shape; + Py_ssize_t *_strides; + Py_ssize_t itemsize; + PyObject *mode; + PyObject *_format; + void (*callback_free_data)(void *); + int free_data; + int dtype_is_object; +}; + + +/* "View.MemoryView":280 + * + * @cname('__pyx_MemviewEnum') + * cdef class Enum(object): # <<<<<<<<<<<<<< + * cdef object name + * def __init__(self, name): + */ +struct __pyx_MemviewEnum_obj { + PyObject_HEAD + PyObject *name; +}; + + +/* "View.MemoryView":331 + * + * @cname('__pyx_memoryview') + * cdef class memoryview(object): # <<<<<<<<<<<<<< + * + * cdef object obj + */ +struct __pyx_memoryview_obj { + PyObject_HEAD + struct __pyx_vtabstruct_memoryview *__pyx_vtab; + PyObject *obj; + PyObject *_size; + PyObject *_array_interface; + PyThread_type_lock lock; + __pyx_atomic_int acquisition_count[2]; + __pyx_atomic_int *acquisition_count_aligned_p; + Py_buffer view; + int flags; + int dtype_is_object; + __Pyx_TypeInfo *typeinfo; +}; + + +/* "View.MemoryView":967 + * + * @cname('__pyx_memoryviewslice') + * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< + * "Internal class for passing memoryview slices to Python" + * + */ +struct __pyx_memoryviewslice_obj { + struct __pyx_memoryview_obj __pyx_base; + __Pyx_memviewslice from_slice; + PyObject *from_object; + PyObject *(*to_object_func)(char *); + int (*to_dtype_func)(char *, PyObject *); +}; + + + +/* "View.MemoryView":106 + * + * @cname("__pyx_array") + * cdef class array: # <<<<<<<<<<<<<< + * + * cdef: + */ + +struct __pyx_vtabstruct_array { + PyObject *(*get_memview)(struct __pyx_array_obj *); +}; +static struct __pyx_vtabstruct_array *__pyx_vtabptr_array; + + +/* "View.MemoryView":331 + * + * @cname('__pyx_memoryview') + * cdef class memoryview(object): # <<<<<<<<<<<<<< + * + * cdef object obj + */ + +struct __pyx_vtabstruct_memoryview { + char *(*get_item_pointer)(struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*is_slice)(struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*setitem_slice_assignment)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); + PyObject *(*setitem_slice_assign_scalar)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*setitem_indexed)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); + PyObject *(*convert_item_to_object)(struct __pyx_memoryview_obj *, char *); + PyObject *(*assign_item_from_object)(struct __pyx_memoryview_obj *, char *, PyObject *); +}; +static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview; + + +/* "View.MemoryView":967 + * + * @cname('__pyx_memoryviewslice') + * cdef class _memoryviewslice(memoryview): # <<<<<<<<<<<<<< + * "Internal class for passing memoryview slices to Python" + * + */ + +struct __pyx_vtabstruct__memoryviewslice { + struct __pyx_vtabstruct_memoryview __pyx_base; +}; +static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice; + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, int); + void (*DECREF)(void*, PyObject*, int); + void (*GOTREF)(void*, PyObject*, int); + void (*GIVEREF)(void*, PyObject*, int); + void* (*SetupContext)(const char*, int, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; +#ifdef WITH_THREAD + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\ + } +#else + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__) +#endif + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__) + #define __Pyx_XINCREF(r) do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* 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 + +/* 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); + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely((Py_TYPE(obj) == type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#define __Pyx_PyErr_Occurred() __pyx_tstate->curexc_type +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* RaiseException.proto */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* PyCFunctionFastCall.proto */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs); +#else +#define __Pyx_PyCFunction_FastCall(func, args, nargs) (assert(0), NULL) +#endif + +/* PyFunctionFastCall.proto */ +#if CYTHON_FAST_PYCALL +#define __Pyx_PyFunction_FastCall(func, args, nargs)\ + __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL) +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs); +#else +#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs) +#endif +#define __Pyx_BUILD_ASSERT_EXPR(cond)\ + (sizeof(char [1 - 2*!(cond)]) - 1) +#ifndef Py_MEMBER_SIZE +#define Py_MEMBER_SIZE(type, member) sizeof(((type *)0)->member) +#endif +#if CYTHON_FAST_PYCALL + static size_t __pyx_pyframe_localsplus_offset = 0; + #include "frameobject.h" +#if PY_VERSION_HEX >= 0x030b00a6 + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif + #define __Pxy_PyFrame_Initialize_Offsets()\ + ((void)__Pyx_BUILD_ASSERT_EXPR(sizeof(PyFrameObject) == offsetof(PyFrameObject, f_localsplus) + Py_MEMBER_SIZE(PyFrameObject, f_localsplus)),\ + (void)(__pyx_pyframe_localsplus_offset = ((size_t)PyFrame_Type.tp_basicsize) - Py_MEMBER_SIZE(PyFrameObject, f_localsplus))) + #define __Pyx_PyFrame_GetLocalsplus(frame)\ + (assert(__pyx_pyframe_localsplus_offset), (PyObject **)(((char *)(frame)) + __pyx_pyframe_localsplus_offset)) +#endif // CYTHON_FAST_PYCALL +#endif + +/* PyObjectCall2Args.proto */ +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* StrEquals.proto */ +#if PY_MAJOR_VERSION >= 3 +#define __Pyx_PyString_Equals __Pyx_PyUnicode_Equals +#else +#define __Pyx_PyString_Equals __Pyx_PyBytes_Equals +#endif + +/* DivInt[Py_ssize_t].proto */ +static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t, Py_ssize_t); + +/* UnaryNegOverflows.proto */ +#define UNARY_NEG_WOULD_OVERFLOW(x)\ + (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x))) + +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *); /*proto*/ +/* GetAttr.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck); +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck); + +/* ObjectGetItem.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject* key); +#else +#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) +#endif + +/* decode_c_string_utf16.proto */ +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = 0; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16LE(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = -1; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} +static CYTHON_INLINE PyObject *__Pyx_PyUnicode_DecodeUTF16BE(const char *s, Py_ssize_t size, const char *errors) { + int byteorder = 1; + return PyUnicode_DecodeUTF16(s, size, errors, &byteorder); +} + +/* decode_c_string.proto */ +static CYTHON_INLINE PyObject* __Pyx_decode_c_string( + const char* cstring, Py_ssize_t start, Py_ssize_t stop, + const char* encoding, const char* errors, + PyObject* (*decode_func)(const char *s, Py_ssize_t size, const char *errors)); + +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* GetAttr3.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); + +/* PyDictVersioning.proto */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) +#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ + (version_var) = __PYX_GET_DICT_VERSION(dict);\ + (cache_var) = (value); +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ + (VAR) = __pyx_dict_cached_value;\ + } else {\ + (VAR) = __pyx_dict_cached_value = (LOOKUP);\ + __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ + }\ +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); +#else +#define __PYX_GET_DICT_VERSION(dict) (0) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); +#endif + +/* GetModuleGlobalName.proto */ +#if CYTHON_USE_DICT_VERSIONS +#define __Pyx_GetModuleGlobalName(var, name) do {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_d))) ?\ + (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ + __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ + PY_UINT64_T __pyx_dict_version;\ + PyObject *__pyx_dict_cached_value;\ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); +#else +#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) +#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); +#endif + +/* 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 +} + +/* None.proto */ +static CYTHON_INLINE void __Pyx_RaiseUnboundLocalError(const char *varname); + +/* DivInt[long].proto */ +static CYTHON_INLINE long __Pyx_div_long(long, long); + +/* PySequenceContains.proto */ +static CYTHON_INLINE int __Pyx_PySequence_ContainsTF(PyObject* item, PyObject* seq, int eq) { + int result = PySequence_Contains(seq, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +/* ImportFrom.proto */ +static PyObject* __Pyx_ImportFrom(PyObject* module, PyObject* name); + +/* HasAttr.proto */ +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); + +/* 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_dsds_nn_int32_t(PyObject *, int writable_flag); + +/* GCCDiagnostics.proto */ +#if defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + +/* MemviewSliceCopyTemplate.proto */ +static __Pyx_memviewslice +__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, + const char *mode, int ndim, + size_t sizeof_dtype, int contig_flag, + int dtype_is_object); + +/* 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 *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value); + +/* 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 'libc.stdint' */ + +/* Module declarations from 'cython.view' */ + +/* Module declarations from 'cython' */ + +/* Module declarations from 'zoo.board_games.tictactoe.envs.legal_actions_cython' */ +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 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_nn_int32_t = { "int32_t", NULL, sizeof(int32_t), { 0 }, 0, IS_UNSIGNED(int32_t) ? 'U' : 'I', IS_UNSIGNED(int32_t), 0 }; +#define __Pyx_MODULE_NAME "zoo.board_games.tictactoe.envs.legal_actions_cython" +extern int __pyx_module_is_main_zoo__board_games__tictactoe__envs__legal_actions_cython; +int __pyx_module_is_main_zoo__board_games__tictactoe__envs__legal_actions_cython = 0; + +/* Implementation of 'zoo.board_games.tictactoe.envs.legal_actions_cython' */ +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_i[] = "i"; +static const char __pyx_k_j[] = "j"; +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_test[] = "__test__"; +static const char __pyx_k_ASCII[] = "ASCII"; +static const char __pyx_k_board[] = "board"; +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_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_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_legal_actions[] = "legal_actions"; +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_legal_actions_cython[] = "legal_actions_cython"; +static const char __pyx_k_strided_and_indirect[] = ""; +static const char __pyx_k_contiguous_and_direct[] = ""; +static const char __pyx_k_MemoryView_of_r_object[] = ""; +static const char __pyx_k_MemoryView_of_r_at_0x_x[] = ""; +static const char __pyx_k_contiguous_and_indirect[] = ""; +static const char __pyx_k_Cannot_index_with_type_s[] = "Cannot index with type '%s'"; +static const char __pyx_k_Invalid_shape_in_axis_d_d[] = "Invalid shape in axis %d: %d."; +static const char __pyx_k_itemsize_0_for_cython_array[] = "itemsize <= 0 for cython.array"; +static const char __pyx_k_unable_to_allocate_array_data[] = "unable to allocate array data."; +static const char __pyx_k_strided_and_direct_or_indirect[] = ""; +static const char __pyx_k_Buffer_view_does_not_expose_stri[] = "Buffer view does not expose strides"; +static const char __pyx_k_Can_only_create_a_buffer_that_is[] = "Can only create a buffer that is contiguous in memory."; +static const char __pyx_k_Cannot_assign_to_read_only_memor[] = "Cannot assign to read-only memoryview"; +static const char __pyx_k_Cannot_create_writable_memory_vi[] = "Cannot create writable memory view from read-only memoryview"; +static const char __pyx_k_Empty_shape_tuple_for_cython_arr[] = "Empty shape tuple for cython.array"; +static const char __pyx_k_Incompatible_checksums_0x_x_vs_0[] = "Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))"; +static const char __pyx_k_Indirect_dimensions_not_supporte[] = "Indirect dimensions not supported"; +static const char __pyx_k_Invalid_mode_expected_c_or_fortr[] = "Invalid mode, expected 'c' or 'fortran', got %s"; +static const char __pyx_k_Out_of_bounds_on_buffer_access_a[] = "Out of bounds on buffer access (axis %d)"; +static const char __pyx_k_Unable_to_convert_item_to_object[] = "Unable to convert item to object"; +static const char __pyx_k_got_differing_extents_in_dimensi[] = "got differing extents in dimension %d (got %d and %d)"; +static const char __pyx_k_no_default___reduce___due_to_non[] = "no default __reduce__ due to non-trivial __cinit__"; +static const char __pyx_k_unable_to_allocate_shape_and_str[] = "unable to allocate shape and strides."; +static const char __pyx_k_zoo_board_games_tictactoe_envs_l[] = "zoo/board_games/tictactoe/envs/legal_actions_cython.pyx"; +static const char __pyx_k_zoo_board_games_tictactoe_envs_l_2[] = "zoo.board_games.tictactoe.envs.legal_actions_cython"; +static PyObject *__pyx_n_s_ASCII; +static PyObject *__pyx_kp_s_Buffer_view_does_not_expose_stri; +static PyObject *__pyx_kp_s_Can_only_create_a_buffer_that_is; +static PyObject *__pyx_kp_s_Cannot_assign_to_read_only_memor; +static PyObject *__pyx_kp_s_Cannot_create_writable_memory_vi; +static PyObject *__pyx_kp_s_Cannot_index_with_type_s; +static PyObject *__pyx_n_s_Ellipsis; +static PyObject *__pyx_kp_s_Empty_shape_tuple_for_cython_arr; +static PyObject *__pyx_kp_s_Incompatible_checksums_0x_x_vs_0; +static PyObject *__pyx_n_s_IndexError; +static PyObject *__pyx_kp_s_Indirect_dimensions_not_supporte; +static PyObject *__pyx_kp_s_Invalid_mode_expected_c_or_fortr; +static PyObject *__pyx_kp_s_Invalid_shape_in_axis_d_d; +static PyObject *__pyx_n_s_MemoryError; +static PyObject *__pyx_kp_s_MemoryView_of_r_at_0x_x; +static PyObject *__pyx_kp_s_MemoryView_of_r_object; +static PyObject *__pyx_n_b_O; +static PyObject *__pyx_kp_s_Out_of_bounds_on_buffer_access_a; +static PyObject *__pyx_n_s_PickleError; +static PyObject *__pyx_n_s_TypeError; +static PyObject *__pyx_kp_s_Unable_to_convert_item_to_object; +static PyObject *__pyx_n_s_ValueError; +static PyObject *__pyx_n_s_View_MemoryView; +static PyObject *__pyx_n_s_allocate_buffer; +static PyObject *__pyx_n_s_base; +static PyObject *__pyx_n_s_board; +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_i; +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_j; +static PyObject *__pyx_n_s_legal_actions; +static PyObject *__pyx_n_s_legal_actions_cython; +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_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_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_kp_s_zoo_board_games_tictactoe_envs_l; +static PyObject *__pyx_n_s_zoo_board_games_tictactoe_envs_l_2; +static PyObject *__pyx_pf_3zoo_11board_games_9tictactoe_4envs_20legal_actions_cython_legal_actions_cython(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_board); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr); /* proto */ +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ +static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object); /* proto */ +static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_int_0; +static PyObject *__pyx_int_1; +static PyObject *__pyx_int_112105877; +static PyObject *__pyx_int_136983863; +static PyObject *__pyx_int_184977713; +static PyObject *__pyx_int_neg_1; +static PyObject *__pyx_tuple_; +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__15; +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__16; +static PyObject *__pyx_tuple__17; +static PyObject *__pyx_tuple__18; +static PyObject *__pyx_tuple__19; +static PyObject *__pyx_tuple__20; +static PyObject *__pyx_tuple__22; +static PyObject *__pyx_tuple__23; +static PyObject *__pyx_tuple__24; +static PyObject *__pyx_tuple__25; +static PyObject *__pyx_tuple__26; +static PyObject *__pyx_tuple__27; +static PyObject *__pyx_codeobj__21; +static PyObject *__pyx_codeobj__28; +/* Late includes */ + +/* "zoo/board_games/tictactoe/envs/legal_actions_cython.pyx":6 + * @cython.boundscheck(False) # Disable bounds checking for performance + * @cython.wraparound(False) # Disable negative indexing for performance + * def legal_actions_cython(int32_t[:, :] board): # <<<<<<<<<<<<<< + * # Use a Python list to store possible legal actions + * cdef list legal_actions = [] + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_3zoo_11board_games_9tictactoe_4envs_20legal_actions_cython_1legal_actions_cython(PyObject *__pyx_self, PyObject *__pyx_arg_board); /*proto*/ +static PyMethodDef __pyx_mdef_3zoo_11board_games_9tictactoe_4envs_20legal_actions_cython_1legal_actions_cython = {"legal_actions_cython", (PyCFunction)__pyx_pw_3zoo_11board_games_9tictactoe_4envs_20legal_actions_cython_1legal_actions_cython, METH_O, 0}; +static PyObject *__pyx_pw_3zoo_11board_games_9tictactoe_4envs_20legal_actions_cython_1legal_actions_cython(PyObject *__pyx_self, PyObject *__pyx_arg_board) { + __Pyx_memviewslice __pyx_v_board = { 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("legal_actions_cython (wrapper)", 0); + assert(__pyx_arg_board); { + __pyx_v_board = __Pyx_PyObject_to_MemoryviewSlice_dsds_nn_int32_t(__pyx_arg_board, PyBUF_WRITABLE); if (unlikely(!__pyx_v_board.memview)) __PYX_ERR(0, 6, __pyx_L3_error) + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + __Pyx_AddTraceback("zoo.board_games.tictactoe.envs.legal_actions_cython.legal_actions_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_3zoo_11board_games_9tictactoe_4envs_20legal_actions_cython_legal_actions_cython(__pyx_self, __pyx_v_board); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_3zoo_11board_games_9tictactoe_4envs_20legal_actions_cython_legal_actions_cython(CYTHON_UNUSED PyObject *__pyx_self, __Pyx_memviewslice __pyx_v_board) { + PyObject *__pyx_v_legal_actions = 0; + int __pyx_v_i; + int __pyx_v_j; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + Py_ssize_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("legal_actions_cython", 0); + + /* "zoo/board_games/tictactoe/envs/legal_actions_cython.pyx":8 + * def legal_actions_cython(int32_t[:, :] board): + * # Use a Python list to store possible legal actions + * cdef list legal_actions = [] # <<<<<<<<<<<<<< + * cdef int i, j + * + */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_legal_actions = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "zoo/board_games/tictactoe/envs/legal_actions_cython.pyx":12 + * + * # Iterate over each position on the board + * for i in range(3): # <<<<<<<<<<<<<< + * for j in range(3): + * # If the current position is empty (value is 0), it is a legal action + */ + for (__pyx_t_2 = 0; __pyx_t_2 < 3; __pyx_t_2+=1) { + __pyx_v_i = __pyx_t_2; + + /* "zoo/board_games/tictactoe/envs/legal_actions_cython.pyx":13 + * # Iterate over each position on the board + * for i in range(3): + * for j in range(3): # <<<<<<<<<<<<<< + * # If the current position is empty (value is 0), it is a legal action + * if board[i, j] == 0: + */ + for (__pyx_t_3 = 0; __pyx_t_3 < 3; __pyx_t_3+=1) { + __pyx_v_j = __pyx_t_3; + + /* "zoo/board_games/tictactoe/envs/legal_actions_cython.pyx":15 + * for j in range(3): + * # If the current position is empty (value is 0), it is a legal action + * if board[i, j] == 0: # <<<<<<<<<<<<<< + * # Add the legal action to the list, representing it as an integer + * legal_actions.append(i * 3 + j) + */ + __pyx_t_4 = __pyx_v_i; + __pyx_t_5 = __pyx_v_j; + __pyx_t_6 = (((*((int32_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_board.data + __pyx_t_4 * __pyx_v_board.strides[0]) ) + __pyx_t_5 * __pyx_v_board.strides[1]) ))) == 0) != 0); + if (__pyx_t_6) { + + /* "zoo/board_games/tictactoe/envs/legal_actions_cython.pyx":17 + * if board[i, j] == 0: + * # Add the legal action to the list, representing it as an integer + * legal_actions.append(i * 3 + j) # <<<<<<<<<<<<<< + * + * # Return the Python list containing all legal actions + */ + __pyx_t_1 = __Pyx_PyInt_From_long(((__pyx_v_i * 3) + __pyx_v_j)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = __Pyx_PyList_Append(__pyx_v_legal_actions, __pyx_t_1); if (unlikely(__pyx_t_7 == ((int)-1))) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "zoo/board_games/tictactoe/envs/legal_actions_cython.pyx":15 + * for j in range(3): + * # If the current position is empty (value is 0), it is a legal action + * if board[i, j] == 0: # <<<<<<<<<<<<<< + * # Add the legal action to the list, representing it as an integer + * legal_actions.append(i * 3 + j) + */ + } + } + } + + /* "zoo/board_games/tictactoe/envs/legal_actions_cython.pyx":20 + * + * # Return the Python list containing all legal actions + * return legal_actions # <<<<<<<<<<<<<< + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_legal_actions); + __pyx_r = __pyx_v_legal_actions; + goto __pyx_L0; + + /* "zoo/board_games/tictactoe/envs/legal_actions_cython.pyx":6 + * @cython.boundscheck(False) # Disable bounds checking for performance + * @cython.wraparound(False) # Disable negative indexing for performance + * def legal_actions_cython(int32_t[:, :] board): # <<<<<<<<<<<<<< + * # Use a Python list to store possible legal actions + * cdef list legal_actions = [] + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("zoo.board_games.tictactoe.envs.legal_actions_cython.legal_actions_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __PYX_XDEC_MEMVIEW(&__pyx_v_board, 1); + __Pyx_XDECREF(__pyx_v_legal_actions); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":123 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): + * + */ + +/* Python wrapper */ +static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_shape = 0; + Py_ssize_t __pyx_v_itemsize; + PyObject *__pyx_v_format = 0; + PyObject *__pyx_v_mode = 0; + int __pyx_v_allocate_buffer; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_shape,&__pyx_n_s_itemsize,&__pyx_n_s_format,&__pyx_n_s_mode,&__pyx_n_s_allocate_buffer,0}; + PyObject* values[5] = {0,0,0,0,0}; + values[3] = ((PyObject *)__pyx_n_s_c); + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_shape)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_itemsize)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 1); __PYX_ERR(1, 123, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_format)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, 2); __PYX_ERR(1, 123, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 3: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_mode); + if (value) { values[3] = value; kw_args--; } + } + CYTHON_FALLTHROUGH; + case 4: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_allocate_buffer); + if (value) { values[4] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 123, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 5: values[4] = PyTuple_GET_ITEM(__pyx_args, 4); + CYTHON_FALLTHROUGH; + case 4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3); + CYTHON_FALLTHROUGH; + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_shape = ((PyObject*)values[0]); + __pyx_v_itemsize = __Pyx_PyIndex_AsSsize_t(values[1]); if (unlikely((__pyx_v_itemsize == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 123, __pyx_L3_error) + __pyx_v_format = values[2]; + __pyx_v_mode = values[3]; + if (values[4]) { + __pyx_v_allocate_buffer = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_allocate_buffer == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 124, __pyx_L3_error) + } else { + + /* "View.MemoryView":124 + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, + * mode="c", bint allocate_buffer=True): # <<<<<<<<<<<<<< + * + * cdef int idx + */ + __pyx_v_allocate_buffer = ((int)1); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 123, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_shape), (&PyTuple_Type), 1, "shape", 1))) __PYX_ERR(1, 123, __pyx_L1_error) + if (unlikely(((PyObject *)__pyx_v_format) == Py_None)) { + PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "format"); __PYX_ERR(1, 123, __pyx_L1_error) + } + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v_shape, __pyx_v_itemsize, __pyx_v_format, __pyx_v_mode, __pyx_v_allocate_buffer); + + /* "View.MemoryView":123 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): + * + */ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer) { + int __pyx_v_idx; + Py_ssize_t __pyx_v_i; + Py_ssize_t __pyx_v_dim; + PyObject **__pyx_v_p; + char __pyx_v_order; + int __pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + char *__pyx_t_7; + int __pyx_t_8; + Py_ssize_t __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + Py_ssize_t __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + __Pyx_INCREF(__pyx_v_format); + + /* "View.MemoryView":130 + * cdef PyObject **p + * + * self.ndim = len(shape) # <<<<<<<<<<<<<< + * self.itemsize = itemsize + * + */ + if (unlikely(__pyx_v_shape == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 130, __pyx_L1_error) + } + __pyx_t_1 = PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 130, __pyx_L1_error) + __pyx_v_self->ndim = ((int)__pyx_t_1); + + /* "View.MemoryView":131 + * + * self.ndim = len(shape) + * self.itemsize = itemsize # <<<<<<<<<<<<<< + * + * if not self.ndim: + */ + __pyx_v_self->itemsize = __pyx_v_itemsize; + + /* "View.MemoryView":133 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError("Empty shape tuple for cython.array") + * + */ + __pyx_t_2 = ((!(__pyx_v_self->ndim != 0)) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":134 + * + * if not self.ndim: + * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< + * + * if itemsize <= 0: + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple_, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 134, __pyx_L1_error) + + /* "View.MemoryView":133 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError("Empty shape tuple for cython.array") + * + */ + } + + /* "View.MemoryView":136 + * raise ValueError("Empty shape tuple for cython.array") + * + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError("itemsize <= 0 for cython.array") + * + */ + __pyx_t_2 = ((__pyx_v_itemsize <= 0) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":137 + * + * if itemsize <= 0: + * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< + * + * if not isinstance(format, bytes): + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__2, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 137, __pyx_L1_error) + + /* "View.MemoryView":136 + * raise ValueError("Empty shape tuple for cython.array") + * + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError("itemsize <= 0 for cython.array") + * + */ + } + + /* "View.MemoryView":139 + * raise ValueError("itemsize <= 0 for cython.array") + * + * if not isinstance(format, bytes): # <<<<<<<<<<<<<< + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string + */ + __pyx_t_2 = PyBytes_Check(__pyx_v_format); + __pyx_t_4 = ((!(__pyx_t_2 != 0)) != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":140 + * + * if not isinstance(format, bytes): + * format = format.encode('ASCII') # <<<<<<<<<<<<<< + * self._format = format # keep a reference to the byte string + * self.format = self._format + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_format, __pyx_n_s_encode); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + } + } + __pyx_t_3 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_5, __pyx_t_6, __pyx_n_s_ASCII) : __Pyx_PyObject_CallOneArg(__pyx_t_5, __pyx_n_s_ASCII); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":139 + * raise ValueError("itemsize <= 0 for cython.array") + * + * if not isinstance(format, bytes): # <<<<<<<<<<<<<< + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string + */ + } + + /* "View.MemoryView":141 + * if not isinstance(format, bytes): + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string # <<<<<<<<<<<<<< + * self.format = self._format + * + */ + if (!(likely(PyBytes_CheckExact(__pyx_v_format))||((__pyx_v_format) == Py_None)||((void)PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_v_format)->tp_name), 0))) __PYX_ERR(1, 141, __pyx_L1_error) + __pyx_t_3 = __pyx_v_format; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_self->_format); + __Pyx_DECREF(__pyx_v_self->_format); + __pyx_v_self->_format = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":142 + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string + * self.format = self._format # <<<<<<<<<<<<<< + * + * + */ + if (unlikely(__pyx_v_self->_format == Py_None)) { + PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); + __PYX_ERR(1, 142, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(1, 142, __pyx_L1_error) + __pyx_v_self->format = __pyx_t_7; + + /* "View.MemoryView":145 + * + * + * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) # <<<<<<<<<<<<<< + * self._strides = self._shape + self.ndim + * + */ + __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2))); + + /* "View.MemoryView":146 + * + * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) + * self._strides = self._shape + self.ndim # <<<<<<<<<<<<<< + * + * if not self._shape: + */ + __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim); + + /* "View.MemoryView":148 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate shape and strides.") + * + */ + __pyx_t_4 = ((!(__pyx_v_self->_shape != 0)) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":149 + * + * if not self._shape: + * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 149, __pyx_L1_error) + + /* "View.MemoryView":148 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate shape and strides.") + * + */ + } + + /* "View.MemoryView":152 + * + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + */ + __pyx_t_8 = 0; + __pyx_t_3 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_3); __pyx_t_1 = 0; + for (;;) { + if (__pyx_t_1 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_1); __Pyx_INCREF(__pyx_t_5); __pyx_t_1++; if (unlikely(0 < 0)) __PYX_ERR(1, 152, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_3, __pyx_t_1); __pyx_t_1++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 152, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_dim = __pyx_t_9; + __pyx_v_idx = __pyx_t_8; + __pyx_t_8 = (__pyx_t_8 + 1); + + /* "View.MemoryView":153 + * + * for idx, dim in enumerate(shape): + * if dim <= 0: # <<<<<<<<<<<<<< + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim + */ + __pyx_t_4 = ((__pyx_v_dim <= 0) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":154 + * for idx, dim in enumerate(shape): + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) # <<<<<<<<<<<<<< + * self._shape[idx] = dim + * + */ + __pyx_t_5 = __Pyx_PyInt_From_int(__pyx_v_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_6); + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyString_Format(__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_t_10); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_6); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 154, __pyx_L1_error) + + /* "View.MemoryView":153 + * + * for idx, dim in enumerate(shape): + * if dim <= 0: # <<<<<<<<<<<<<< + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim + */ + } + + /* "View.MemoryView":155 + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + * self._shape[idx] = dim # <<<<<<<<<<<<<< + * + * cdef char order + */ + (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim; + + /* "View.MemoryView":152 + * + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError("Invalid shape in axis %d: %d." % (idx, dim)) + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":158 + * + * cdef char order + * if mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' + */ + __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_fortran, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 158, __pyx_L1_error) + if (__pyx_t_4) { + + /* "View.MemoryView":159 + * cdef char order + * if mode == 'fortran': + * order = b'F' # <<<<<<<<<<<<<< + * self.mode = u'fortran' + * elif mode == 'c': + */ + __pyx_v_order = 'F'; + + /* "View.MemoryView":160 + * if mode == 'fortran': + * order = b'F' + * self.mode = u'fortran' # <<<<<<<<<<<<<< + * elif mode == 'c': + * order = b'C' + */ + __Pyx_INCREF(__pyx_n_u_fortran); + __Pyx_GIVEREF(__pyx_n_u_fortran); + __Pyx_GOTREF(__pyx_v_self->mode); + __Pyx_DECREF(__pyx_v_self->mode); + __pyx_v_self->mode = __pyx_n_u_fortran; + + /* "View.MemoryView":158 + * + * cdef char order + * if mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' + */ + goto __pyx_L10; + } + + /* "View.MemoryView":161 + * order = b'F' + * self.mode = u'fortran' + * elif mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' + */ + __pyx_t_4 = (__Pyx_PyString_Equals(__pyx_v_mode, __pyx_n_s_c, Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(1, 161, __pyx_L1_error) + if (likely(__pyx_t_4)) { + + /* "View.MemoryView":162 + * self.mode = u'fortran' + * elif mode == 'c': + * order = b'C' # <<<<<<<<<<<<<< + * self.mode = u'c' + * else: + */ + __pyx_v_order = 'C'; + + /* "View.MemoryView":163 + * elif mode == 'c': + * order = b'C' + * self.mode = u'c' # <<<<<<<<<<<<<< + * else: + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) + */ + __Pyx_INCREF(__pyx_n_u_c); + __Pyx_GIVEREF(__pyx_n_u_c); + __Pyx_GOTREF(__pyx_v_self->mode); + __Pyx_DECREF(__pyx_v_self->mode); + __pyx_v_self->mode = __pyx_n_u_c; + + /* "View.MemoryView":161 + * order = b'F' + * self.mode = u'fortran' + * elif mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' + */ + goto __pyx_L10; + } + + /* "View.MemoryView":165 + * self.mode = u'c' + * else: + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) # <<<<<<<<<<<<<< + * + * self.len = fill_contig_strides_array(self._shape, self._strides, + */ + /*else*/ { + __pyx_t_3 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_v_mode); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_10 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 165, __pyx_L1_error) + } + __pyx_L10:; + + /* "View.MemoryView":167 + * raise ValueError("Invalid mode, expected 'c' or 'fortran', got %s" % mode) + * + * self.len = fill_contig_strides_array(self._shape, self._strides, # <<<<<<<<<<<<<< + * itemsize, self.ndim, order) + * + */ + __pyx_v_self->len = __pyx_fill_contig_strides_array(__pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_itemsize, __pyx_v_self->ndim, __pyx_v_order); + + /* "View.MemoryView":170 + * itemsize, self.ndim, order) + * + * self.free_data = allocate_buffer # <<<<<<<<<<<<<< + * self.dtype_is_object = format == b'O' + * if allocate_buffer: + */ + __pyx_v_self->free_data = __pyx_v_allocate_buffer; + + /* "View.MemoryView":171 + * + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<< + * if allocate_buffer: + * + */ + __pyx_t_10 = PyObject_RichCompare(__pyx_v_format, __pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 171, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 171, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_v_self->dtype_is_object = __pyx_t_4; + + /* "View.MemoryView":172 + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' + * if allocate_buffer: # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_4 = (__pyx_v_allocate_buffer != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":175 + * + * + * self.data = malloc(self.len) # <<<<<<<<<<<<<< + * if not self.data: + * raise MemoryError("unable to allocate array data.") + */ + __pyx_v_self->data = ((char *)malloc(__pyx_v_self->len)); + + /* "View.MemoryView":176 + * + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate array data.") + * + */ + __pyx_t_4 = ((!(__pyx_v_self->data != 0)) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":177 + * self.data = malloc(self.len) + * if not self.data: + * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< + * + * if self.dtype_is_object: + */ + __pyx_t_10 = __Pyx_PyObject_Call(__pyx_builtin_MemoryError, __pyx_tuple__4, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_Raise(__pyx_t_10, 0, 0, 0); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __PYX_ERR(1, 177, __pyx_L1_error) + + /* "View.MemoryView":176 + * + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError("unable to allocate array data.") + * + */ + } + + /* "View.MemoryView":179 + * raise MemoryError("unable to allocate array data.") + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len / itemsize): + */ + __pyx_t_4 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":180 + * + * if self.dtype_is_object: + * p = self.data # <<<<<<<<<<<<<< + * for i in range(self.len / itemsize): + * p[i] = Py_None + */ + __pyx_v_p = ((PyObject **)__pyx_v_self->data); + + /* "View.MemoryView":181 + * if self.dtype_is_object: + * p = self.data + * for i in range(self.len / itemsize): # <<<<<<<<<<<<<< + * p[i] = Py_None + * Py_INCREF(Py_None) + */ + if (unlikely(__pyx_v_itemsize == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); + __PYX_ERR(1, 181, __pyx_L1_error) + } + else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) { + PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); + __PYX_ERR(1, 181, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_itemsize); + __pyx_t_9 = __pyx_t_1; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_9; __pyx_t_11+=1) { + __pyx_v_i = __pyx_t_11; + + /* "View.MemoryView":182 + * p = self.data + * for i in range(self.len / itemsize): + * p[i] = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * + */ + (__pyx_v_p[__pyx_v_i]) = Py_None; + + /* "View.MemoryView":183 + * for i in range(self.len / itemsize): + * p[i] = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + Py_INCREF(Py_None); + } + + /* "View.MemoryView":179 + * raise MemoryError("unable to allocate array data.") + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len / itemsize): + */ + } + + /* "View.MemoryView":172 + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' + * if allocate_buffer: # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":123 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_format); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":186 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * cdef int bufmode = -1 + * if self.mode == u"c": + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(((struct __pyx_array_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_bufmode; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + char *__pyx_t_4; + Py_ssize_t __pyx_t_5; + int __pyx_t_6; + Py_ssize_t *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + if (__pyx_v_info == NULL) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + + /* "View.MemoryView":187 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 # <<<<<<<<<<<<<< + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + */ + __pyx_v_bufmode = -1; + + /* "View.MemoryView":188 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + */ + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_c, Py_EQ)); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 188, __pyx_L1_error) + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":189 + * cdef int bufmode = -1 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + */ + __pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); + + /* "View.MemoryView":188 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + */ + goto __pyx_L3; + } + + /* "View.MemoryView":190 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": # <<<<<<<<<<<<<< + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + */ + __pyx_t_2 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_n_u_fortran, Py_EQ)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 190, __pyx_L1_error) + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":191 + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") + */ + __pyx_v_bufmode = (PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); + + /* "View.MemoryView":190 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": # <<<<<<<<<<<<<< + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + */ + } + __pyx_L3:; + + /* "View.MemoryView":192 + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): # <<<<<<<<<<<<<< + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data + */ + __pyx_t_1 = ((!((__pyx_v_flags & __pyx_v_bufmode) != 0)) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":193 + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") # <<<<<<<<<<<<<< + * info.buf = self.data + * info.len = self.len + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 193, __pyx_L1_error) + + /* "View.MemoryView":192 + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): # <<<<<<<<<<<<<< + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data + */ + } + + /* "View.MemoryView":194 + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data # <<<<<<<<<<<<<< + * info.len = self.len + * info.ndim = self.ndim + */ + __pyx_t_4 = __pyx_v_self->data; + __pyx_v_info->buf = __pyx_t_4; + + /* "View.MemoryView":195 + * raise ValueError("Can only create a buffer that is contiguous in memory.") + * info.buf = self.data + * info.len = self.len # <<<<<<<<<<<<<< + * info.ndim = self.ndim + * info.shape = self._shape + */ + __pyx_t_5 = __pyx_v_self->len; + __pyx_v_info->len = __pyx_t_5; + + /* "View.MemoryView":196 + * info.buf = self.data + * info.len = self.len + * info.ndim = self.ndim # <<<<<<<<<<<<<< + * info.shape = self._shape + * info.strides = self._strides + */ + __pyx_t_6 = __pyx_v_self->ndim; + __pyx_v_info->ndim = __pyx_t_6; + + /* "View.MemoryView":197 + * info.len = self.len + * info.ndim = self.ndim + * info.shape = self._shape # <<<<<<<<<<<<<< + * info.strides = self._strides + * info.suboffsets = NULL + */ + __pyx_t_7 = __pyx_v_self->_shape; + __pyx_v_info->shape = __pyx_t_7; + + /* "View.MemoryView":198 + * info.ndim = self.ndim + * info.shape = self._shape + * info.strides = self._strides # <<<<<<<<<<<<<< + * info.suboffsets = NULL + * info.itemsize = self.itemsize + */ + __pyx_t_7 = __pyx_v_self->_strides; + __pyx_v_info->strides = __pyx_t_7; + + /* "View.MemoryView":199 + * info.shape = self._shape + * info.strides = self._strides + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = self.itemsize + * info.readonly = 0 + */ + __pyx_v_info->suboffsets = NULL; + + /* "View.MemoryView":200 + * info.strides = self._strides + * info.suboffsets = NULL + * info.itemsize = self.itemsize # <<<<<<<<<<<<<< + * info.readonly = 0 + * + */ + __pyx_t_5 = __pyx_v_self->itemsize; + __pyx_v_info->itemsize = __pyx_t_5; + + /* "View.MemoryView":201 + * info.suboffsets = NULL + * info.itemsize = self.itemsize + * info.readonly = 0 # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + __pyx_v_info->readonly = 0; + + /* "View.MemoryView":203 + * info.readonly = 0 + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.format + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":204 + * + * if flags & PyBUF_FORMAT: + * info.format = self.format # <<<<<<<<<<<<<< + * else: + * info.format = NULL + */ + __pyx_t_4 = __pyx_v_self->format; + __pyx_v_info->format = __pyx_t_4; + + /* "View.MemoryView":203 + * info.readonly = 0 + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.format + * else: + */ + goto __pyx_L5; + } + + /* "View.MemoryView":206 + * info.format = self.format + * else: + * info.format = NULL # <<<<<<<<<<<<<< + * + * info.obj = self + */ + /*else*/ { + __pyx_v_info->format = NULL; + } + __pyx_L5:; + + /* "View.MemoryView":208 + * info.format = NULL + * + * info.obj = self # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + */ + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + + /* "View.MemoryView":186 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * cdef int bufmode = -1 + * if self.mode == u"c": + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.array.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":212 + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + * + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + */ + +/* Python wrapper */ +static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_array___dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) { + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":213 + * + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data: + */ + __pyx_t_1 = ((__pyx_v_self->callback_free_data != NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":214 + * def __dealloc__(array self): + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) # <<<<<<<<<<<<<< + * elif self.free_data: + * if self.dtype_is_object: + */ + __pyx_v_self->callback_free_data(__pyx_v_self->data); + + /* "View.MemoryView":213 + * + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":215 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, + */ + __pyx_t_1 = (__pyx_v_self->free_data != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":216 + * self.callback_free_data(self.data) + * elif self.free_data: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + */ + __pyx_t_1 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":217 + * elif self.free_data: + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, # <<<<<<<<<<<<<< + * self._strides, self.ndim, False) + * free(self.data) + */ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_self->data, __pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_self->ndim, 0); + + /* "View.MemoryView":216 + * self.callback_free_data(self.data) + * elif self.free_data: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + */ + } + + /* "View.MemoryView":219 + * refcount_objects_in_slice(self.data, self._shape, + * self._strides, self.ndim, False) + * free(self.data) # <<<<<<<<<<<<<< + * PyObject_Free(self._shape) + * + */ + free(__pyx_v_self->data); + + /* "View.MemoryView":215 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, + */ + } + __pyx_L3:; + + /* "View.MemoryView":220 + * self._strides, self.ndim, False) + * free(self.data) + * PyObject_Free(self._shape) # <<<<<<<<<<<<<< + * + * @property + */ + PyObject_Free(__pyx_v_self->_shape); + + /* "View.MemoryView":212 + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") + * + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":223 + * + * @property + * def memview(self): # <<<<<<<<<<<<<< + * return self.get_memview() + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_5array_7memview___get__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":224 + * @property + * def memview(self): + * return self.get_memview() # <<<<<<<<<<<<<< + * + * @cname('get_memview') + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_array *)__pyx_v_self->__pyx_vtab)->get_memview(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":223 + * + * @property + * def memview(self): # <<<<<<<<<<<<<< + * return self.get_memview() + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.memview.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":227 + * + * @cname('get_memview') + * cdef get_memview(self): # <<<<<<<<<<<<<< + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) + */ + +static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) { + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_memview", 0); + + /* "View.MemoryView":228 + * @cname('get_memview') + * cdef get_memview(self): + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE # <<<<<<<<<<<<<< + * return memoryview(self, flags, self.dtype_is_object) + * + */ + __pyx_v_flags = ((PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) | PyBUF_WRITABLE); + + /* "View.MemoryView":229 + * cdef get_memview(self): + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) # <<<<<<<<<<<<<< + * + * def __len__(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":227 + * + * @cname('get_memview') + * cdef get_memview(self): # <<<<<<<<<<<<<< + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.array.get_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":231 + * return memoryview(self, flags, self.dtype_is_object) + * + * def __len__(self): # <<<<<<<<<<<<<< + * return self._shape[0] + * + */ + +/* Python wrapper */ +static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self); /*proto*/ +static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__", 0); + + /* "View.MemoryView":232 + * + * def __len__(self): + * return self._shape[0] # <<<<<<<<<<<<<< + * + * def __getattr__(self, attr): + */ + __pyx_r = (__pyx_v_self->_shape[0]); + goto __pyx_L0; + + /* "View.MemoryView":231 + * return memoryview(self, flags, self.dtype_is_object) + * + * def __len__(self): # <<<<<<<<<<<<<< + * return self._shape[0] + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":234 + * return self._shape[0] + * + * def __getattr__(self, attr): # <<<<<<<<<<<<<< + * return getattr(self.memview, attr) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr); /*proto*/ +static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_attr)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getattr__", 0); + + /* "View.MemoryView":235 + * + * def __getattr__(self, attr): + * return getattr(self.memview, attr) # <<<<<<<<<<<<<< + * + * def __getitem__(self, item): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_GetAttr(__pyx_t_1, __pyx_v_attr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":234 + * return self._shape[0] + * + * def __getattr__(self, attr): # <<<<<<<<<<<<<< + * return getattr(self.memview, attr) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.array.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":237 + * return getattr(self.memview, attr) + * + * def __getitem__(self, item): # <<<<<<<<<<<<<< + * return self.memview[item] + * + */ + +/* Python wrapper */ +static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/ +static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "View.MemoryView":238 + * + * def __getitem__(self, item): + * return self.memview[item] # <<<<<<<<<<<<<< + * + * def __setitem__(self, item, value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":237 + * return getattr(self.memview, attr) + * + * def __getitem__(self, item): # <<<<<<<<<<<<<< + * return self.memview[item] + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":240 + * return self.memview[item] + * + * def __setitem__(self, item, value): # <<<<<<<<<<<<<< + * self.memview[item] = value + * + */ + +/* Python wrapper */ +static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + + /* "View.MemoryView":241 + * + * def __setitem__(self, item, value): + * self.memview[item] = value # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(PyObject_SetItem(__pyx_t_1, __pyx_v_item, __pyx_v_value) < 0)) __PYX_ERR(1, 241, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":240 + * return self.memview[item] + * + * def __setitem__(self, item, value): # <<<<<<<<<<<<<< + * self.memview[item] = value + * + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__6, 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__7, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":245 + * + * @cname("__pyx_array_new") + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< + * char *mode, char *buf): + * cdef array result + */ + +static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, char *__pyx_v_format, char *__pyx_v_mode, char *__pyx_v_buf) { + struct __pyx_array_obj *__pyx_v_result = 0; + struct __pyx_array_obj *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("array_cwrapper", 0); + + /* "View.MemoryView":249 + * cdef array result + * + * if buf == NULL: # <<<<<<<<<<<<<< + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + */ + __pyx_t_1 = ((__pyx_v_buf == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":250 + * + * if buf == NULL: + * result = array(shape, itemsize, format, mode.decode('ASCII')) # <<<<<<<<<<<<<< + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), + */ + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_shape); + __Pyx_GIVEREF(__pyx_v_shape); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_shape); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_5, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":249 + * cdef array result + * + * if buf == NULL: # <<<<<<<<<<<<<< + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":252 + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< + * allocate_buffer=False) + * result.data = buf + */ + /*else*/ { + __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_mode, 0, strlen(__pyx_v_mode), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(4); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v_shape); + __Pyx_GIVEREF(__pyx_v_shape); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v_shape); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_t_3); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_3 = 0; + + /* "View.MemoryView":253 + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), + * allocate_buffer=False) # <<<<<<<<<<<<<< + * result.data = buf + * + */ + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 253, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_n_s_allocate_buffer, Py_False) < 0) __PYX_ERR(1, 253, __pyx_L1_error) + + /* "View.MemoryView":252 + * result = array(shape, itemsize, format, mode.decode('ASCII')) + * else: + * result = array(shape, itemsize, format, mode.decode('ASCII'), # <<<<<<<<<<<<<< + * allocate_buffer=False) + * result.data = buf + */ + __pyx_t_5 = __Pyx_PyObject_Call(((PyObject *)__pyx_array_type), __pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 252, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_5); + __pyx_t_5 = 0; + + /* "View.MemoryView":254 + * result = array(shape, itemsize, format, mode.decode('ASCII'), + * allocate_buffer=False) + * result.data = buf # <<<<<<<<<<<<<< + * + * return result + */ + __pyx_v_result->data = __pyx_v_buf; + } + __pyx_L3:; + + /* "View.MemoryView":256 + * result.data = buf + * + * return result # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "View.MemoryView":245 + * + * @cname("__pyx_array_new") + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, # <<<<<<<<<<<<<< + * char *mode, char *buf): + * cdef array result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":282 + * cdef class Enum(object): + * cdef object name + * def __init__(self, name): # <<<<<<<<<<<<<< + * self.name = name + * def __repr__(self): + */ + +/* Python wrapper */ +static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_name = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_name,0}; + PyObject* values[1] = {0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_name)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__init__") < 0)) __PYX_ERR(1, 282, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 1) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + } + __pyx_v_name = values[0]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 282, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.Enum.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v_name); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__", 0); + + /* "View.MemoryView":283 + * cdef object name + * def __init__(self, name): + * self.name = name # <<<<<<<<<<<<<< + * def __repr__(self): + * return self.name + */ + __Pyx_INCREF(__pyx_v_name); + __Pyx_GIVEREF(__pyx_v_name); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = __pyx_v_name; + + /* "View.MemoryView":282 + * cdef class Enum(object): + * cdef object name + * def __init__(self, name): # <<<<<<<<<<<<<< + * self.name = name + * def __repr__(self): + */ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":284 + * def __init__(self, name): + * self.name = name + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name + * + */ + +/* Python wrapper */ +static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "View.MemoryView":285 + * self.name = name + * def __repr__(self): + * return self.name # <<<<<<<<<<<<<< + * + * cdef generic = Enum("") + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->name); + __pyx_r = __pyx_v_self->name; + goto __pyx_L0; + + /* "View.MemoryView":284 + * def __init__(self, name): + * self.name = name + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_MemviewEnum___reduce_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.name,) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->name); + __Pyx_GIVEREF(__pyx_v_self->name); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None: + * state += (_dict,) + */ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_n_s_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + __pyx_t_2 = (__pyx_v__dict != Py_None); + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: + */ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict); + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "(tree fragment)":9 + * if _dict is not None: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.name is not None + */ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True + */ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.name is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + */ + /*else*/ { + __pyx_t_3 = (__pyx_v_self->name != Py_None); + __pyx_v_use_setstate = __pyx_t_3; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + */ + __pyx_t_3 = (__pyx_v_use_setstate != 0); + if (__pyx_t_3) { + + /* "(tree fragment)":13 + * use_setstate = self.name is not None + * if use_setstate: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_INCREF(__pyx_int_184977713); + __Pyx_GIVEREF(__pyx_int_184977713); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + */ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Enum, (type(self), 0xb068931, None), state + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Enum__set_state(self, __pyx_state) + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_n_s_pyx_unpickle_Enum); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_INCREF(__pyx_int_184977713); + __Pyx_GIVEREF(__pyx_int_184977713); + PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_int_184977713); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.Enum.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state(self, __pyx_state) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), ((PyObject *)__pyx_v___pyx_state)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Enum__set_state(self, __pyx_state) # <<<<<<<<<<<<<< + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||((void)PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 17, __pyx_L1_error) + __pyx_t_1 = __pyx_unpickle_Enum__set_state(__pyx_v_self, ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Enum, (type(self), 0xb068931, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state(self, __pyx_state) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":299 + * + * @cname('__pyx_align_pointer') + * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory + */ + +static void *__pyx_align_pointer(void *__pyx_v_memory, size_t __pyx_v_alignment) { + Py_intptr_t __pyx_v_aligned_p; + size_t __pyx_v_offset; + void *__pyx_r; + int __pyx_t_1; + + /* "View.MemoryView":301 + * cdef void *align_pointer(void *memory, size_t alignment) nogil: + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory # <<<<<<<<<<<<<< + * cdef size_t offset + * + */ + __pyx_v_aligned_p = ((Py_intptr_t)__pyx_v_memory); + + /* "View.MemoryView":305 + * + * with cython.cdivision(True): + * offset = aligned_p % alignment # <<<<<<<<<<<<<< + * + * if offset > 0: + */ + __pyx_v_offset = (__pyx_v_aligned_p % __pyx_v_alignment); + + /* "View.MemoryView":307 + * offset = aligned_p % alignment + * + * if offset > 0: # <<<<<<<<<<<<<< + * aligned_p += alignment - offset + * + */ + __pyx_t_1 = ((__pyx_v_offset > 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":308 + * + * if offset > 0: + * aligned_p += alignment - offset # <<<<<<<<<<<<<< + * + * return aligned_p + */ + __pyx_v_aligned_p = (__pyx_v_aligned_p + (__pyx_v_alignment - __pyx_v_offset)); + + /* "View.MemoryView":307 + * offset = aligned_p % alignment + * + * if offset > 0: # <<<<<<<<<<<<<< + * aligned_p += alignment - offset + * + */ + } + + /* "View.MemoryView":310 + * aligned_p += alignment - offset + * + * return aligned_p # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = ((void *)__pyx_v_aligned_p); + goto __pyx_L0; + + /* "View.MemoryView":299 + * + * @cname('__pyx_align_pointer') + * cdef void *align_pointer(void *memory, size_t alignment) nogil: # <<<<<<<<<<<<<< + * "Align pointer memory on a given boundary" + * cdef Py_intptr_t aligned_p = memory + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":346 + * cdef __Pyx_TypeInfo *typeinfo + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< + * self.obj = obj + * self.flags = flags + */ + +/* Python wrapper */ +static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_obj = 0; + int __pyx_v_flags; + int __pyx_v_dtype_is_object; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_obj,&__pyx_n_s_flags,&__pyx_n_s_dtype_is_object,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_obj)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_flags)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, 1); __PYX_ERR(1, 346, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (kw_args > 0) { + PyObject* value = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_dtype_is_object); + if (value) { values[2] = value; kw_args--; } + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__cinit__") < 0)) __PYX_ERR(1, 346, __pyx_L3_error) + } + } else { + switch (PyTuple_GET_SIZE(__pyx_args)) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_obj = values[0]; + __pyx_v_flags = __Pyx_PyInt_As_int(values[1]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 346, __pyx_L3_error) + if (values[2]) { + __pyx_v_dtype_is_object = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_dtype_is_object == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 346, __pyx_L3_error) + } else { + __pyx_v_dtype_is_object = ((int)0); + } + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 346, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_obj, __pyx_v_flags, __pyx_v_dtype_is_object); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "View.MemoryView":347 + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): + * self.obj = obj # <<<<<<<<<<<<<< + * self.flags = flags + * if type(self) is memoryview or obj is not None: + */ + __Pyx_INCREF(__pyx_v_obj); + __Pyx_GIVEREF(__pyx_v_obj); + __Pyx_GOTREF(__pyx_v_self->obj); + __Pyx_DECREF(__pyx_v_self->obj); + __pyx_v_self->obj = __pyx_v_obj; + + /* "View.MemoryView":348 + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): + * self.obj = obj + * self.flags = flags # <<<<<<<<<<<<<< + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) + */ + __pyx_v_self->flags = __pyx_v_flags; + + /* "View.MemoryView":349 + * self.obj = obj + * self.flags = flags + * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: + */ + __pyx_t_2 = (((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))) == ((PyObject *)__pyx_memoryview_type)); + __pyx_t_3 = (__pyx_t_2 != 0); + if (!__pyx_t_3) { + } else { + __pyx_t_1 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = (__pyx_v_obj != Py_None); + __pyx_t_2 = (__pyx_t_3 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "View.MemoryView":350 + * self.flags = flags + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) # <<<<<<<<<<<<<< + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None + */ + __pyx_t_4 = __Pyx_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 350, __pyx_L1_error) + + /* "View.MemoryView":351 + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) + */ + __pyx_t_1 = ((((PyObject *)__pyx_v_self->view.obj) == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":352 + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * + */ + ((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None; + + /* "View.MemoryView":353 + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + */ + Py_INCREF(Py_None); + + /* "View.MemoryView":351 + * if type(self) is memoryview or obj is not None: + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) + */ + } + + /* "View.MemoryView":349 + * self.obj = obj + * self.flags = flags + * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< + * __Pyx_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: + */ + } + + /* "View.MemoryView":355 + * Py_INCREF(Py_None) + * + * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + */ + __pyx_t_1 = ((!(__PYX_CYTHON_ATOMICS_ENABLED() != 0)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":357 + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + */ + __pyx_t_1 = ((__pyx_memoryview_thread_locks_used < 8) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":358 + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: + */ + __pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); + + /* "View.MemoryView":359 + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 # <<<<<<<<<<<<<< + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + */ + __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1); + + /* "View.MemoryView":357 + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: # <<<<<<<<<<<<<< + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + */ + } + + /* "View.MemoryView":360 + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: # <<<<<<<<<<<<<< + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + */ + __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":361 + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() # <<<<<<<<<<<<<< + * if self.lock is NULL: + * raise MemoryError + */ + __pyx_v_self->lock = PyThread_allocate_lock(); + + /* "View.MemoryView":362 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * + */ + __pyx_t_1 = ((__pyx_v_self->lock == NULL) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":363 + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + PyErr_NoMemory(); __PYX_ERR(1, 363, __pyx_L1_error) + + /* "View.MemoryView":362 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * + */ + } + + /* "View.MemoryView":360 + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: # <<<<<<<<<<<<<< + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + */ + } + + /* "View.MemoryView":355 + * Py_INCREF(Py_None) + * + * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< + * global __pyx_memoryview_thread_locks_used + * if __pyx_memoryview_thread_locks_used < THREAD_LOCKS_PREALLOCATED: + */ + } + + /* "View.MemoryView":365 + * raise MemoryError + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":366 + * + * if flags & PyBUF_FORMAT: + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') # <<<<<<<<<<<<<< + * else: + * self.dtype_is_object = dtype_is_object + */ + __pyx_t_2 = (((__pyx_v_self->view.format[0]) == 'O') != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L12_bool_binop_done; + } + __pyx_t_2 = (((__pyx_v_self->view.format[1]) == '\x00') != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L12_bool_binop_done:; + __pyx_v_self->dtype_is_object = __pyx_t_1; + + /* "View.MemoryView":365 + * raise MemoryError + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: + */ + goto __pyx_L11; + } + + /* "View.MemoryView":368 + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: + * self.dtype_is_object = dtype_is_object # <<<<<<<<<<<<<< + * + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( + */ + /*else*/ { + __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object; + } + __pyx_L11:; + + /* "View.MemoryView":370 + * self.dtype_is_object = dtype_is_object + * + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( # <<<<<<<<<<<<<< + * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) + * self.typeinfo = NULL + */ + __pyx_v_self->acquisition_count_aligned_p = ((__pyx_atomic_int *)__pyx_align_pointer(((void *)(&(__pyx_v_self->acquisition_count[0]))), (sizeof(__pyx_atomic_int)))); + + /* "View.MemoryView":372 + * self.acquisition_count_aligned_p = <__pyx_atomic_int *> align_pointer( + * &self.acquisition_count[0], sizeof(__pyx_atomic_int)) + * self.typeinfo = NULL # <<<<<<<<<<<<<< + * + * def __dealloc__(memoryview self): + */ + __pyx_v_self->typeinfo = NULL; + + /* "View.MemoryView":346 + * cdef __Pyx_TypeInfo *typeinfo + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< + * self.obj = obj + * self.flags = flags + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":374 + * self.typeinfo = NULL + * + * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + */ + +/* Python wrapper */ +static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self) { + int __pyx_v_i; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyThread_type_lock __pyx_t_6; + PyThread_type_lock __pyx_t_7; + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":375 + * + * def __dealloc__(memoryview self): + * if self.obj is not None: # <<<<<<<<<<<<<< + * __Pyx_ReleaseBuffer(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + */ + __pyx_t_1 = (__pyx_v_self->obj != Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":376 + * def __dealloc__(memoryview self): + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) # <<<<<<<<<<<<<< + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + * + */ + __Pyx_ReleaseBuffer((&__pyx_v_self->view)); + + /* "View.MemoryView":375 + * + * def __dealloc__(memoryview self): + * if self.obj is not None: # <<<<<<<<<<<<<< + * __Pyx_ReleaseBuffer(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":377 + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< + * + * (<__pyx_buffer *> &self.view).obj = NULL + */ + __pyx_t_2 = ((((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":379 + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + * + * (<__pyx_buffer *> &self.view).obj = NULL # <<<<<<<<<<<<<< + * Py_DECREF(Py_None) + * + */ + ((Py_buffer *)(&__pyx_v_self->view))->obj = NULL; + + /* "View.MemoryView":380 + * + * (<__pyx_buffer *> &self.view).obj = NULL + * Py_DECREF(Py_None) # <<<<<<<<<<<<<< + * + * cdef int i + */ + Py_DECREF(Py_None); + + /* "View.MemoryView":377 + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< + * + * (<__pyx_buffer *> &self.view).obj = NULL + */ + } + __pyx_L3:; + + /* "View.MemoryView":384 + * cdef int i + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: # <<<<<<<<<<<<<< + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: + */ + __pyx_t_2 = ((__pyx_v_self->lock != NULL) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":385 + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: + * for i in range(__pyx_memoryview_thread_locks_used): # <<<<<<<<<<<<<< + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + */ + __pyx_t_3 = __pyx_memoryview_thread_locks_used; + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "View.MemoryView":386 + * if self.lock != NULL: + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + */ + __pyx_t_2 = (((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":387 + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 # <<<<<<<<<<<<<< + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + */ + __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used - 1); + + /* "View.MemoryView":388 + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + */ + __pyx_t_2 = ((__pyx_v_i != __pyx_memoryview_thread_locks_used) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":390 + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) # <<<<<<<<<<<<<< + * break + * else: + */ + __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); + __pyx_t_7 = (__pyx_memoryview_thread_locks[__pyx_v_i]); + + /* "View.MemoryView":389 + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + * break + */ + (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_6; + (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_7; + + /* "View.MemoryView":388 + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + */ + } + + /* "View.MemoryView":391 + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + * break # <<<<<<<<<<<<<< + * else: + * PyThread_free_lock(self.lock) + */ + goto __pyx_L6_break; + + /* "View.MemoryView":386 + * if self.lock != NULL: + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + */ + } + } + /*else*/ { + + /* "View.MemoryView":393 + * break + * else: + * PyThread_free_lock(self.lock) # <<<<<<<<<<<<<< + * + * cdef char *get_item_pointer(memoryview self, object index) except NULL: + */ + PyThread_free_lock(__pyx_v_self->lock); + } + __pyx_L6_break:; + + /* "View.MemoryView":384 + * cdef int i + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: # <<<<<<<<<<<<<< + * for i in range(__pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: + */ + } + + /* "View.MemoryView":374 + * self.typeinfo = NULL + * + * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< + * if self.obj is not None: + * __Pyx_ReleaseBuffer(&self.view) + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":395 + * PyThread_free_lock(self.lock) + * + * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf + */ + +static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { + Py_ssize_t __pyx_v_dim; + char *__pyx_v_itemp; + PyObject *__pyx_v_idx = NULL; + char *__pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *(*__pyx_t_4)(PyObject *); + PyObject *__pyx_t_5 = NULL; + Py_ssize_t __pyx_t_6; + char *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_item_pointer", 0); + + /* "View.MemoryView":397 + * cdef char *get_item_pointer(memoryview self, object index) except NULL: + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf # <<<<<<<<<<<<<< + * + * for dim, idx in enumerate(index): + */ + __pyx_v_itemp = ((char *)__pyx_v_self->view.buf); + + /* "View.MemoryView":399 + * cdef char *itemp = self.view.buf + * + * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * + */ + __pyx_t_1 = 0; + if (likely(PyList_CheckExact(__pyx_v_index)) || PyTuple_CheckExact(__pyx_v_index)) { + __pyx_t_2 = __pyx_v_index; __Pyx_INCREF(__pyx_t_2); __pyx_t_3 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = Py_TYPE(__pyx_t_2)->tp_iternext; if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 399, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + if (__pyx_t_3 >= PyList_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyList_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 399, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } else { + if (__pyx_t_3 >= PyTuple_GET_SIZE(__pyx_t_2)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3); __Pyx_INCREF(__pyx_t_5); __pyx_t_3++; if (unlikely(0 < 0)) __PYX_ERR(1, 399, __pyx_L1_error) + #else + __pyx_t_5 = PySequence_ITEM(__pyx_t_2, __pyx_t_3); __pyx_t_3++; if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 399, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + } + } else { + __pyx_t_5 = __pyx_t_4(__pyx_t_2); + if (unlikely(!__pyx_t_5)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 399, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_v_dim = __pyx_t_1; + __pyx_t_1 = (__pyx_t_1 + 1); + + /* "View.MemoryView":400 + * + * for dim, idx in enumerate(index): + * itemp = pybuffer_index(&self.view, itemp, idx, dim) # <<<<<<<<<<<<<< + * + * return itemp + */ + __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 400, __pyx_L1_error) + __pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((char *)NULL))) __PYX_ERR(1, 400, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_7; + + /* "View.MemoryView":399 + * cdef char *itemp = self.view.buf + * + * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * + */ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":402 + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * + * return itemp # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_itemp; + goto __pyx_L0; + + /* "View.MemoryView":395 + * PyThread_free_lock(self.lock) + * + * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.get_item_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_idx); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":405 + * + * + * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< + * if index is Ellipsis: + * return self + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index); /*proto*/ +static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { + PyObject *__pyx_v_have_slices = NULL; + PyObject *__pyx_v_indices = NULL; + char *__pyx_v_itemp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + char *__pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "View.MemoryView":406 + * + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self + * + */ + __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":407 + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: + * return self # <<<<<<<<<<<<<< + * + * have_slices, indices = _unellipsify(index, self.view.ndim) + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "View.MemoryView":406 + * + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self + * + */ + } + + /* "View.MemoryView":409 + * return self + * + * have_slices, indices = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< + * + * cdef char *itemp + */ + __pyx_t_3 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (likely(__pyx_t_3 != Py_None)) { + PyObject* sequence = __pyx_t_3; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 409, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + #else + __pyx_t_4 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 409, __pyx_L1_error) + } + __pyx_v_have_slices = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_v_indices = __pyx_t_5; + __pyx_t_5 = 0; + + /* "View.MemoryView":412 + * + * cdef char *itemp + * if have_slices: # <<<<<<<<<<<<<< + * return memview_slice(self, indices) + * else: + */ + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 412, __pyx_L1_error) + if (__pyx_t_2) { + + /* "View.MemoryView":413 + * cdef char *itemp + * if have_slices: + * return memview_slice(self, indices) # <<<<<<<<<<<<<< + * else: + * itemp = self.get_item_pointer(indices) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 413, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":412 + * + * cdef char *itemp + * if have_slices: # <<<<<<<<<<<<<< + * return memview_slice(self, indices) + * else: + */ + } + + /* "View.MemoryView":415 + * return memview_slice(self, indices) + * else: + * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< + * return self.convert_item_to_object(itemp) + * + */ + /*else*/ { + __pyx_t_6 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_6 == ((char *)NULL))) __PYX_ERR(1, 415, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_6; + + /* "View.MemoryView":416 + * else: + * itemp = self.get_item_pointer(indices) + * return self.convert_item_to_object(itemp) # <<<<<<<<<<<<<< + * + * def __setitem__(memoryview self, object index, object value): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":405 + * + * + * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< + * if index is Ellipsis: + * return self + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_have_slices); + __Pyx_XDECREF(__pyx_v_indices); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":418 + * return self.convert_item_to_object(itemp) + * + * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") + */ + +/* Python wrapper */ +static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + PyObject *__pyx_v_have_slices = NULL; + PyObject *__pyx_v_obj = NULL; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + __Pyx_INCREF(__pyx_v_index); + + /* "View.MemoryView":419 + * + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError("Cannot assign to read-only memoryview") + * + */ + __pyx_t_1 = (__pyx_v_self->view.readonly != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":420 + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< + * + * have_slices, index = _unellipsify(index, self.view.ndim) + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__8, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 420, __pyx_L1_error) + + /* "View.MemoryView":419 + * + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError("Cannot assign to read-only memoryview") + * + */ + } + + /* "View.MemoryView":422 + * raise TypeError("Cannot assign to read-only memoryview") + * + * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< + * + * if have_slices: + */ + __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(__pyx_t_2 != Py_None)) { + PyObject* sequence = __pyx_t_2; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 422, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_3 = PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 422, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 422, __pyx_L1_error) + } + __pyx_v_have_slices = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":424 + * have_slices, index = _unellipsify(index, self.view.ndim) + * + * if have_slices: # <<<<<<<<<<<<<< + * obj = self.is_slice(value) + * if obj: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 424, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":425 + * + * if have_slices: + * obj = self.is_slice(value) # <<<<<<<<<<<<<< + * if obj: + * self.setitem_slice_assignment(self[index], obj) + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v_obj = __pyx_t_2; + __pyx_t_2 = 0; + + /* "View.MemoryView":426 + * if have_slices: + * obj = self.is_slice(value) + * if obj: # <<<<<<<<<<<<<< + * self.setitem_slice_assignment(self[index], obj) + * else: + */ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_obj); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 426, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":427 + * obj = self.is_slice(value) + * if obj: + * self.setitem_slice_assignment(self[index], obj) # <<<<<<<<<<<<<< + * else: + * self.setitem_slice_assign_scalar(self[index], value) + */ + __pyx_t_2 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_2, __pyx_v_obj); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":426 + * if have_slices: + * obj = self.is_slice(value) + * if obj: # <<<<<<<<<<<<<< + * self.setitem_slice_assignment(self[index], obj) + * else: + */ + goto __pyx_L5; + } + + /* "View.MemoryView":429 + * self.setitem_slice_assignment(self[index], obj) + * else: + * self.setitem_slice_assign_scalar(self[index], value) # <<<<<<<<<<<<<< + * else: + * self.setitem_indexed(index, value) + */ + /*else*/ { + __pyx_t_4 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_memoryview_type))))) __PYX_ERR(1, 429, __pyx_L1_error) + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_4), __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 429, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L5:; + + /* "View.MemoryView":424 + * have_slices, index = _unellipsify(index, self.view.ndim) + * + * if have_slices: # <<<<<<<<<<<<<< + * obj = self.is_slice(value) + * if obj: + */ + goto __pyx_L4; + } + + /* "View.MemoryView":431 + * self.setitem_slice_assign_scalar(self[index], value) + * else: + * self.setitem_indexed(index, value) # <<<<<<<<<<<<<< + * + * cdef is_slice(self, obj): + */ + /*else*/ { + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 431, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L4:; + + /* "View.MemoryView":418 + * return self.convert_item_to_object(itemp) + * + * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView.memoryview.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_have_slices); + __Pyx_XDECREF(__pyx_v_obj); + __Pyx_XDECREF(__pyx_v_index); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":433 + * self.setitem_indexed(index, value) + * + * cdef is_slice(self, obj): # <<<<<<<<<<<<<< + * if not isinstance(obj, memoryview): + * try: + */ + +static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_slice", 0); + __Pyx_INCREF(__pyx_v_obj); + + /* "View.MemoryView":434 + * + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + */ + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_obj, __pyx_memoryview_type); + __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":435 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + /*try:*/ { + + /* "View.MemoryView":436 + * if not isinstance(obj, memoryview): + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< + * self.dtype_is_object) + * except TypeError: + */ + __pyx_t_6 = __Pyx_PyInt_From_int(((__pyx_v_self->flags & (~PyBUF_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 436, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_6); + + /* "View.MemoryView":437 + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) # <<<<<<<<<<<<<< + * except TypeError: + * return None + */ + __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 437, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_7); + + /* "View.MemoryView":436 + * if not isinstance(obj, memoryview): + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< + * self.dtype_is_object) + * except TypeError: + */ + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 436, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_v_obj); + __Pyx_GIVEREF(__pyx_v_obj); + PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_v_obj); + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_t_7); + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_8, NULL); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 436, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF_SET(__pyx_v_obj, __pyx_t_7); + __pyx_t_7 = 0; + + /* "View.MemoryView":435 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + */ + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L9_try_end; + __pyx_L4_error:; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "View.MemoryView":438 + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + * except TypeError: # <<<<<<<<<<<<<< + * return None + * + */ + __pyx_t_9 = __Pyx_PyErr_ExceptionMatches(__pyx_builtin_TypeError); + if (__pyx_t_9) { + __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_6) < 0) __PYX_ERR(1, 438, __pyx_L6_except_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GOTREF(__pyx_t_6); + + /* "View.MemoryView":439 + * self.dtype_is_object) + * except TypeError: + * return None # <<<<<<<<<<<<<< + * + * return obj + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L7_except_return; + } + goto __pyx_L6_except_error; + __pyx_L6_except_error:; + + /* "View.MemoryView":435 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + */ + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + goto __pyx_L1_error; + __pyx_L7_except_return:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + goto __pyx_L0; + __pyx_L9_try_end:; + } + + /* "View.MemoryView":434 + * + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + */ + } + + /* "View.MemoryView":441 + * return None + * + * return obj # <<<<<<<<<<<<<< + * + * cdef setitem_slice_assignment(self, dst, src): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_obj); + __pyx_r = __pyx_v_obj; + goto __pyx_L0; + + /* "View.MemoryView":433 + * self.setitem_indexed(index, value) + * + * cdef is_slice(self, obj): # <<<<<<<<<<<<<< + * if not isinstance(obj, memoryview): + * try: + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_obj); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":443 + * return obj + * + * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice dst_slice + * cdef __Pyx_memviewslice src_slice + */ + +static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src) { + __Pyx_memviewslice __pyx_v_dst_slice; + __Pyx_memviewslice __pyx_v_src_slice; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + __Pyx_memviewslice *__pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setitem_slice_assignment", 0); + + /* "View.MemoryView":447 + * cdef __Pyx_memviewslice src_slice + * + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<< + * get_slice_from_memview(dst, &dst_slice)[0], + * src.ndim, dst.ndim, self.dtype_is_object) + */ + if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_memoryview_type))))) __PYX_ERR(1, 447, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_src), (&__pyx_v_src_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 447, __pyx_L1_error) + + /* "View.MemoryView":448 + * + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], + * get_slice_from_memview(dst, &dst_slice)[0], # <<<<<<<<<<<<<< + * src.ndim, dst.ndim, self.dtype_is_object) + * + */ + if (!(likely(((__pyx_v_dst) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_dst, __pyx_memoryview_type))))) __PYX_ERR(1, 448, __pyx_L1_error) + __pyx_t_2 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_2 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 448, __pyx_L1_error) + + /* "View.MemoryView":449 + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], + * get_slice_from_memview(dst, &dst_slice)[0], + * src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<< + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): + */ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 449, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_n_s_ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyInt_As_int(__pyx_t_3); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 449, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":447 + * cdef __Pyx_memviewslice src_slice + * + * memoryview_copy_contents(get_slice_from_memview(src, &src_slice)[0], # <<<<<<<<<<<<<< + * get_slice_from_memview(dst, &dst_slice)[0], + * src.ndim, dst.ndim, self.dtype_is_object) + */ + __pyx_t_6 = __pyx_memoryview_copy_contents((__pyx_t_1[0]), (__pyx_t_2[0]), __pyx_t_4, __pyx_t_5, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 447, __pyx_L1_error) + + /* "View.MemoryView":443 + * return obj + * + * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice dst_slice + * cdef __Pyx_memviewslice src_slice + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assignment", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":451 + * src.ndim, dst.ndim, self.dtype_is_object) + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< + * cdef int array[128] + * cdef void *tmp = NULL + */ + +static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value) { + int __pyx_v_array[0x80]; + void *__pyx_v_tmp; + void *__pyx_v_item; + __Pyx_memviewslice *__pyx_v_dst_slice; + __Pyx_memviewslice __pyx_v_tmp_slice; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + char const *__pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 0); + + /* "View.MemoryView":453 + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): + * cdef int array[128] + * cdef void *tmp = NULL # <<<<<<<<<<<<<< + * cdef void *item + * + */ + __pyx_v_tmp = NULL; + + /* "View.MemoryView":458 + * cdef __Pyx_memviewslice *dst_slice + * cdef __Pyx_memviewslice tmp_slice + * dst_slice = get_slice_from_memview(dst, &tmp_slice) # <<<<<<<<<<<<<< + * + * if self.view.itemsize > sizeof(array): + */ + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 458, __pyx_L1_error) + __pyx_v_dst_slice = __pyx_t_1; + + /* "View.MemoryView":460 + * dst_slice = get_slice_from_memview(dst, &tmp_slice) + * + * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: + */ + __pyx_t_2 = ((((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array))) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":461 + * + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) # <<<<<<<<<<<<<< + * if tmp == NULL: + * raise MemoryError + */ + __pyx_v_tmp = PyMem_Malloc(__pyx_v_self->view.itemsize); + + /* "View.MemoryView":462 + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * item = tmp + */ + __pyx_t_2 = ((__pyx_v_tmp == NULL) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":463 + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * item = tmp + * else: + */ + PyErr_NoMemory(); __PYX_ERR(1, 463, __pyx_L1_error) + + /* "View.MemoryView":462 + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * item = tmp + */ + } + + /* "View.MemoryView":464 + * if tmp == NULL: + * raise MemoryError + * item = tmp # <<<<<<<<<<<<<< + * else: + * item = array + */ + __pyx_v_item = __pyx_v_tmp; + + /* "View.MemoryView":460 + * dst_slice = get_slice_from_memview(dst, &tmp_slice) + * + * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":466 + * item = tmp + * else: + * item = array # <<<<<<<<<<<<<< + * + * try: + */ + /*else*/ { + __pyx_v_item = ((void *)__pyx_v_array); + } + __pyx_L3:; + + /* "View.MemoryView":468 + * item = array + * + * try: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * ( item)[0] = value + */ + /*try:*/ { + + /* "View.MemoryView":469 + * + * try: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * ( item)[0] = value + * else: + */ + __pyx_t_2 = (__pyx_v_self->dtype_is_object != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":470 + * try: + * if self.dtype_is_object: + * ( item)[0] = value # <<<<<<<<<<<<<< + * else: + * self.assign_item_from_object( item, value) + */ + (((PyObject **)__pyx_v_item)[0]) = ((PyObject *)__pyx_v_value); + + /* "View.MemoryView":469 + * + * try: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * ( item)[0] = value + * else: + */ + goto __pyx_L8; + } + + /* "View.MemoryView":472 + * ( item)[0] = value + * else: + * self.assign_item_from_object( item, value) # <<<<<<<<<<<<<< + * + * + */ + /*else*/ { + __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, ((char *)__pyx_v_item), __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 472, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L8:; + + /* "View.MemoryView":476 + * + * + * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, + */ + __pyx_t_2 = ((__pyx_v_self->view.suboffsets != NULL) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":477 + * + * if self.view.suboffsets != NULL: + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) # <<<<<<<<<<<<<< + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, + * item, self.dtype_is_object) + */ + __pyx_t_3 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 477, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":476 + * + * + * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, + */ + } + + /* "View.MemoryView":478 + * if self.view.suboffsets != NULL: + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, # <<<<<<<<<<<<<< + * item, self.dtype_is_object) + * finally: + */ + __pyx_memoryview_slice_assign_scalar(__pyx_v_dst_slice, __pyx_v_dst->view.ndim, __pyx_v_self->view.itemsize, __pyx_v_item, __pyx_v_self->dtype_is_object); + } + + /* "View.MemoryView":481 + * item, self.dtype_is_object) + * finally: + * PyMem_Free(tmp) # <<<<<<<<<<<<<< + * + * cdef setitem_indexed(self, index, value): + */ + /*finally:*/ { + /*normal exit:*/{ + PyMem_Free(__pyx_v_tmp); + goto __pyx_L7; + } + __pyx_L6_error:; + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PY_MAJOR_VERSION >= 3) __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); + if ((PY_MAJOR_VERSION < 3) || unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename; + { + PyMem_Free(__pyx_v_tmp); + } + if (PY_MAJOR_VERSION >= 3) { + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + } + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ErrRestore(__pyx_t_7, __pyx_t_8, __pyx_t_9); + __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; + __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_6; + goto __pyx_L1_error; + } + __pyx_L7:; + } + + /* "View.MemoryView":451 + * src.ndim, dst.ndim, self.dtype_is_object) + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< + * cdef int array[128] + * cdef void *tmp = NULL + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":483 + * PyMem_Free(tmp) + * + * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< + * cdef char *itemp = self.get_item_pointer(index) + * self.assign_item_from_object(itemp, value) + */ + +static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + char *__pyx_v_itemp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setitem_indexed", 0); + + /* "View.MemoryView":484 + * + * cdef setitem_indexed(self, index, value): + * cdef char *itemp = self.get_item_pointer(index) # <<<<<<<<<<<<<< + * self.assign_item_from_object(itemp, value) + * + */ + __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_index); if (unlikely(__pyx_t_1 == ((char *)NULL))) __PYX_ERR(1, 484, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_1; + + /* "View.MemoryView":485 + * cdef setitem_indexed(self, index, value): + * cdef char *itemp = self.get_item_pointer(index) + * self.assign_item_from_object(itemp, value) # <<<<<<<<<<<<<< + * + * cdef convert_item_to_object(self, char *itemp): + */ + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 485, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":483 + * PyMem_Free(tmp) + * + * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< + * cdef char *itemp = self.get_item_pointer(index) + * self.assign_item_from_object(itemp, value) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_indexed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":487 + * self.assign_item_from_object(itemp, value) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + */ + +static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp) { + PyObject *__pyx_v_struct = NULL; + PyObject *__pyx_v_bytesitem = 0; + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; + int __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("convert_item_to_object", 0); + + /* "View.MemoryView":490 + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + * import struct # <<<<<<<<<<<<<< + * cdef bytes bytesitem + * + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_struct = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":493 + * cdef bytes bytesitem + * + * bytesitem = itemp[:self.view.itemsize] # <<<<<<<<<<<<<< + * try: + * result = struct.unpack(self.view.format, bytesitem) + */ + __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_itemp + 0, __pyx_v_self->view.itemsize - 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_bytesitem = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":494 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + */ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + /*try:*/ { + + /* "View.MemoryView":495 + * bytesitem = itemp[:self.view.itemsize] + * try: + * result = struct.unpack(self.view.format, bytesitem) # <<<<<<<<<<<<<< + * except struct.error: + * raise ValueError("Unable to convert item to object") + */ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_unpack); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = NULL; + __pyx_t_8 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + if (likely(__pyx_t_7)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_5, function); + __pyx_t_8 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; + __pyx_t_1 = __Pyx_PyFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_5)) { + PyObject *__pyx_temp[3] = {__pyx_t_7, __pyx_t_6, __pyx_v_bytesitem}; + __pyx_t_1 = __Pyx_PyCFunction_FastCall(__pyx_t_5, __pyx_temp+1-__pyx_t_8, 2+__pyx_t_8); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } else + #endif + { + __pyx_t_9 = PyTuple_New(2+__pyx_t_8); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_9); + if (__pyx_t_7) { + __Pyx_GIVEREF(__pyx_t_7); PyTuple_SET_ITEM(__pyx_t_9, 0, __pyx_t_7); __pyx_t_7 = NULL; + } + __Pyx_GIVEREF(__pyx_t_6); + PyTuple_SET_ITEM(__pyx_t_9, 0+__pyx_t_8, __pyx_t_6); + __Pyx_INCREF(__pyx_v_bytesitem); + __Pyx_GIVEREF(__pyx_v_bytesitem); + PyTuple_SET_ITEM(__pyx_t_9, 1+__pyx_t_8, __pyx_v_bytesitem); + __pyx_t_6 = 0; + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_t_5, __pyx_t_9, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 495, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":494 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + */ + } + + /* "View.MemoryView":499 + * raise ValueError("Unable to convert item to object") + * else: + * if len(self.view.format) == 1: # <<<<<<<<<<<<<< + * return result[0] + * return result + */ + /*else:*/ { + __pyx_t_10 = strlen(__pyx_v_self->view.format); + __pyx_t_11 = ((__pyx_t_10 == 1) != 0); + if (__pyx_t_11) { + + /* "View.MemoryView":500 + * else: + * if len(self.view.format) == 1: + * return result[0] # <<<<<<<<<<<<<< + * return result + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_result, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 500, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L6_except_return; + + /* "View.MemoryView":499 + * raise ValueError("Unable to convert item to object") + * else: + * if len(self.view.format) == 1: # <<<<<<<<<<<<<< + * return result[0] + * return result + */ + } + + /* "View.MemoryView":501 + * if len(self.view.format) == 1: + * return result[0] + * return result # <<<<<<<<<<<<<< + * + * cdef assign_item_from_object(self, char *itemp, object value): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L6_except_return; + } + __pyx_L3_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "View.MemoryView":496 + * try: + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: # <<<<<<<<<<<<<< + * raise ValueError("Unable to convert item to object") + * else: + */ + __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_5, &__pyx_t_9); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_error); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 496, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_6); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_ErrRestore(__pyx_t_1, __pyx_t_5, __pyx_t_9); + __pyx_t_1 = 0; __pyx_t_5 = 0; __pyx_t_9 = 0; + if (__pyx_t_8) { + __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_9, &__pyx_t_5, &__pyx_t_1) < 0) __PYX_ERR(1, 496, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GOTREF(__pyx_t_1); + + /* "View.MemoryView":497 + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< + * else: + * if len(self.view.format) == 1: + */ + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__9, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 497, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(1, 497, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + __pyx_L5_except_error:; + + /* "View.MemoryView":494 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + */ + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L1_error; + __pyx_L6_except_return:; + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L0; + } + + /* "View.MemoryView":487 + * self.assign_item_from_object(itemp, value) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_struct); + __Pyx_XDECREF(__pyx_v_bytesitem); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":503 + * return result + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + */ + +static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { + PyObject *__pyx_v_struct = NULL; + char __pyx_v_c; + PyObject *__pyx_v_bytesvalue = 0; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + Py_ssize_t __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + char *__pyx_t_11; + char *__pyx_t_12; + char *__pyx_t_13; + char *__pyx_t_14; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("assign_item_from_object", 0); + + /* "View.MemoryView":506 + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + * import struct # <<<<<<<<<<<<<< + * cdef char c + * cdef bytes bytesvalue + */ + __pyx_t_1 = __Pyx_Import(__pyx_n_s_struct, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 506, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_struct = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":511 + * cdef Py_ssize_t i + * + * if isinstance(value, tuple): # <<<<<<<<<<<<<< + * bytesvalue = struct.pack(self.view.format, *value) + * else: + */ + __pyx_t_2 = PyTuple_Check(__pyx_v_value); + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "View.MemoryView":512 + * + * if isinstance(value, tuple): + * bytesvalue = struct.pack(self.view.format, *value) # <<<<<<<<<<<<<< + * else: + * bytesvalue = struct.pack(self.view.format, value) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||((void)PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 512, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":511 + * cdef Py_ssize_t i + * + * if isinstance(value, tuple): # <<<<<<<<<<<<<< + * bytesvalue = struct.pack(self.view.format, *value) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":514 + * bytesvalue = struct.pack(self.view.format, *value) + * else: + * bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<< + * + * for i, c in enumerate(bytesvalue): + */ + /*else*/ { + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_n_s_pack); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = NULL; + __pyx_t_7 = 0; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_6, function); + __pyx_t_7 = 1; + } + } + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; + __pyx_t_4 = __Pyx_PyFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(__pyx_t_6)) { + PyObject *__pyx_temp[3] = {__pyx_t_5, __pyx_t_1, __pyx_v_value}; + __pyx_t_4 = __Pyx_PyCFunction_FastCall(__pyx_t_6, __pyx_temp+1-__pyx_t_7, 2+__pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else + #endif + { + __pyx_t_8 = PyTuple_New(2+__pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__pyx_t_5) { + __Pyx_GIVEREF(__pyx_t_5); PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5); __pyx_t_5 = NULL; + } + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_8, 0+__pyx_t_7, __pyx_t_1); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + PyTuple_SET_ITEM(__pyx_t_8, 1+__pyx_t_7, __pyx_v_value); + __pyx_t_1 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_6, __pyx_t_8, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None)||((void)PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "bytes", Py_TYPE(__pyx_t_4)->tp_name), 0))) __PYX_ERR(1, 514, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + } + __pyx_L3:; + + /* "View.MemoryView":516 + * bytesvalue = struct.pack(self.view.format, value) + * + * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< + * itemp[i] = c + * + */ + __pyx_t_9 = 0; + if (unlikely(__pyx_v_bytesvalue == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable"); + __PYX_ERR(1, 516, __pyx_L1_error) + } + __Pyx_INCREF(__pyx_v_bytesvalue); + __pyx_t_10 = __pyx_v_bytesvalue; + __pyx_t_12 = PyBytes_AS_STRING(__pyx_t_10); + __pyx_t_13 = (__pyx_t_12 + PyBytes_GET_SIZE(__pyx_t_10)); + for (__pyx_t_14 = __pyx_t_12; __pyx_t_14 < __pyx_t_13; __pyx_t_14++) { + __pyx_t_11 = __pyx_t_14; + __pyx_v_c = (__pyx_t_11[0]); + + /* "View.MemoryView":517 + * + * for i, c in enumerate(bytesvalue): + * itemp[i] = c # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + __pyx_v_i = __pyx_t_9; + + /* "View.MemoryView":516 + * bytesvalue = struct.pack(self.view.format, value) + * + * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< + * itemp[i] = c + * + */ + __pyx_t_9 = (__pyx_t_9 + 1); + + /* "View.MemoryView":517 + * + * for i, c in enumerate(bytesvalue): + * itemp[i] = c # <<<<<<<<<<<<<< + * + * @cname('getbuffer') + */ + (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c; + } + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "View.MemoryView":503 + * return result + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("View.MemoryView.memoryview.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_struct); + __Pyx_XDECREF(__pyx_v_bytesvalue); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":520 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError("Cannot create writable memory view from read-only memoryview") + */ + +/* Python wrapper */ +static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static CYTHON_UNUSED int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t *__pyx_t_4; + char *__pyx_t_5; + void *__pyx_t_6; + int __pyx_t_7; + Py_ssize_t __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + if (__pyx_v_info == NULL) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + + /* "View.MemoryView":521 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + */ + __pyx_t_2 = ((__pyx_v_flags & PyBUF_WRITABLE) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_self->view.readonly != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":522 + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<< + * + * if flags & PyBUF_ND: + */ + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__10, NULL); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 522, __pyx_L1_error) + + /* "View.MemoryView":521 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + */ + } + + /* "View.MemoryView":524 + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + * if flags & PyBUF_ND: # <<<<<<<<<<<<<< + * info.shape = self.view.shape + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":525 + * + * if flags & PyBUF_ND: + * info.shape = self.view.shape # <<<<<<<<<<<<<< + * else: + * info.shape = NULL + */ + __pyx_t_4 = __pyx_v_self->view.shape; + __pyx_v_info->shape = __pyx_t_4; + + /* "View.MemoryView":524 + * raise ValueError("Cannot create writable memory view from read-only memoryview") + * + * if flags & PyBUF_ND: # <<<<<<<<<<<<<< + * info.shape = self.view.shape + * else: + */ + goto __pyx_L6; + } + + /* "View.MemoryView":527 + * info.shape = self.view.shape + * else: + * info.shape = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_STRIDES: + */ + /*else*/ { + __pyx_v_info->shape = NULL; + } + __pyx_L6:; + + /* "View.MemoryView":529 + * info.shape = NULL + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.strides = self.view.strides + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":530 + * + * if flags & PyBUF_STRIDES: + * info.strides = self.view.strides # <<<<<<<<<<<<<< + * else: + * info.strides = NULL + */ + __pyx_t_4 = __pyx_v_self->view.strides; + __pyx_v_info->strides = __pyx_t_4; + + /* "View.MemoryView":529 + * info.shape = NULL + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.strides = self.view.strides + * else: + */ + goto __pyx_L7; + } + + /* "View.MemoryView":532 + * info.strides = self.view.strides + * else: + * info.strides = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_INDIRECT: + */ + /*else*/ { + __pyx_v_info->strides = NULL; + } + __pyx_L7:; + + /* "View.MemoryView":534 + * info.strides = NULL + * + * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< + * info.suboffsets = self.view.suboffsets + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_INDIRECT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":535 + * + * if flags & PyBUF_INDIRECT: + * info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<< + * else: + * info.suboffsets = NULL + */ + __pyx_t_4 = __pyx_v_self->view.suboffsets; + __pyx_v_info->suboffsets = __pyx_t_4; + + /* "View.MemoryView":534 + * info.strides = NULL + * + * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< + * info.suboffsets = self.view.suboffsets + * else: + */ + goto __pyx_L8; + } + + /* "View.MemoryView":537 + * info.suboffsets = self.view.suboffsets + * else: + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: + */ + /*else*/ { + __pyx_v_info->suboffsets = NULL; + } + __pyx_L8:; + + /* "View.MemoryView":539 + * info.suboffsets = NULL + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.view.format + * else: + */ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":540 + * + * if flags & PyBUF_FORMAT: + * info.format = self.view.format # <<<<<<<<<<<<<< + * else: + * info.format = NULL + */ + __pyx_t_5 = __pyx_v_self->view.format; + __pyx_v_info->format = __pyx_t_5; + + /* "View.MemoryView":539 + * info.suboffsets = NULL + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.view.format + * else: + */ + goto __pyx_L9; + } + + /* "View.MemoryView":542 + * info.format = self.view.format + * else: + * info.format = NULL # <<<<<<<<<<<<<< + * + * info.buf = self.view.buf + */ + /*else*/ { + __pyx_v_info->format = NULL; + } + __pyx_L9:; + + /* "View.MemoryView":544 + * info.format = NULL + * + * info.buf = self.view.buf # <<<<<<<<<<<<<< + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize + */ + __pyx_t_6 = __pyx_v_self->view.buf; + __pyx_v_info->buf = __pyx_t_6; + + /* "View.MemoryView":545 + * + * info.buf = self.view.buf + * info.ndim = self.view.ndim # <<<<<<<<<<<<<< + * info.itemsize = self.view.itemsize + * info.len = self.view.len + */ + __pyx_t_7 = __pyx_v_self->view.ndim; + __pyx_v_info->ndim = __pyx_t_7; + + /* "View.MemoryView":546 + * info.buf = self.view.buf + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize # <<<<<<<<<<<<<< + * info.len = self.view.len + * info.readonly = self.view.readonly + */ + __pyx_t_8 = __pyx_v_self->view.itemsize; + __pyx_v_info->itemsize = __pyx_t_8; + + /* "View.MemoryView":547 + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize + * info.len = self.view.len # <<<<<<<<<<<<<< + * info.readonly = self.view.readonly + * info.obj = self + */ + __pyx_t_8 = __pyx_v_self->view.len; + __pyx_v_info->len = __pyx_t_8; + + /* "View.MemoryView":548 + * info.itemsize = self.view.itemsize + * info.len = self.view.len + * info.readonly = self.view.readonly # <<<<<<<<<<<<<< + * info.obj = self + * + */ + __pyx_t_1 = __pyx_v_self->view.readonly; + __pyx_v_info->readonly = __pyx_t_1; + + /* "View.MemoryView":549 + * info.len = self.view.len + * info.readonly = self.view.readonly + * info.obj = self # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") + */ + __Pyx_INCREF(((PyObject *)__pyx_v_self)); + __Pyx_GIVEREF(((PyObject *)__pyx_v_self)); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + + /* "View.MemoryView":520 + * + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): # <<<<<<<<<<<<<< + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError("Cannot create writable memory view from read-only memoryview") + */ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":555 + * + * @property + * def T(self): # <<<<<<<<<<<<<< + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":556 + * @property + * def T(self): + * cdef _memoryviewslice result = memoryview_copy(self) # <<<<<<<<<<<<<< + * transpose_memslice(&result.from_slice) + * return result + */ + __pyx_t_1 = __pyx_memoryview_copy_object(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 556, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_memoryviewslice_type))))) __PYX_ERR(1, 556, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":557 + * def T(self): + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_t_2 = __pyx_memslice_transpose((&__pyx_v_result->from_slice)); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 557, __pyx_L1_error) + + /* "View.MemoryView":558 + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) + * return result # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "View.MemoryView":555 + * + * @property + * def T(self): # <<<<<<<<<<<<<< + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.T.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":561 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.obj + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":562 + * @property + * def base(self): + * return self.obj # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->obj); + __pyx_r = __pyx_v_self->obj; + goto __pyx_L0; + + /* "View.MemoryView":561 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.obj + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":565 + * + * @property + * def shape(self): # <<<<<<<<<<<<<< + * return tuple([length for length in self.view.shape[:self.view.ndim]]) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_v_length; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":566 + * @property + * def shape(self): + * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); + for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { + __pyx_t_2 = __pyx_t_4; + __pyx_v_length = (__pyx_t_2[0]); + __pyx_t_5 = PyInt_FromSsize_t(__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "View.MemoryView":565 + * + * @property + * def shape(self): # <<<<<<<<<<<<<< + * return tuple([length for length in self.view.shape[:self.view.ndim]]) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.shape.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":569 + * + * @property + * def strides(self): # <<<<<<<<<<<<<< + * if self.view.strides == NULL: + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_v_stride; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":570 + * @property + * def strides(self): + * if self.view.strides == NULL: # <<<<<<<<<<<<<< + * + * raise ValueError("Buffer view does not expose strides") + */ + __pyx_t_1 = ((__pyx_v_self->view.strides == NULL) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":572 + * if self.view.strides == NULL: + * + * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) + */ + __pyx_t_2 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__11, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 572, __pyx_L1_error) + + /* "View.MemoryView":570 + * @property + * def strides(self): + * if self.view.strides == NULL: # <<<<<<<<<<<<<< + * + * raise ValueError("Buffer view does not expose strides") + */ + } + + /* "View.MemoryView":574 + * raise ValueError("Buffer view does not expose strides") + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = (__pyx_v_self->view.strides + __pyx_v_self->view.ndim); + for (__pyx_t_5 = __pyx_v_self->view.strides; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { + __pyx_t_3 = __pyx_t_5; + __pyx_v_stride = (__pyx_t_3[0]); + __pyx_t_6 = PyInt_FromSsize_t(__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; + goto __pyx_L0; + + /* "View.MemoryView":569 + * + * @property + * def strides(self): # <<<<<<<<<<<<<< + * if self.view.strides == NULL: + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView.memoryview.strides.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":577 + * + * @property + * def suboffsets(self): # <<<<<<<<<<<<<< + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_v_suboffset; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + Py_ssize_t *__pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":578 + * @property + * def suboffsets(self): + * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< + * return (-1,) * self.view.ndim + * + */ + __pyx_t_1 = ((__pyx_v_self->view.suboffsets == NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":579 + * def suboffsets(self): + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_tuple__12, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":578 + * @property + * def suboffsets(self): + * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< + * return (-1,) * self.view.ndim + * + */ + } + + /* "View.MemoryView":581 + * return (-1,) * self.view.ndim + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim); + for (__pyx_t_6 = __pyx_v_self->view.suboffsets; __pyx_t_6 < __pyx_t_5; __pyx_t_6++) { + __pyx_t_4 = __pyx_t_6; + __pyx_v_suboffset = (__pyx_t_4[0]); + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_suboffset); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_3, (PyObject*)__pyx_t_2))) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_t_2 = PyList_AsTuple(((PyObject*)__pyx_t_3)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":577 + * + * @property + * def suboffsets(self): # <<<<<<<<<<<<<< + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.suboffsets.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":584 + * + * @property + * def ndim(self): # <<<<<<<<<<<<<< + * return self.view.ndim + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":585 + * @property + * def ndim(self): + * return self.view.ndim # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 585, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":584 + * + * @property + * def ndim(self): # <<<<<<<<<<<<<< + * return self.view.ndim + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.ndim.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":588 + * + * @property + * def itemsize(self): # <<<<<<<<<<<<<< + * return self.view.itemsize + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":589 + * @property + * def itemsize(self): + * return self.view.itemsize # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":588 + * + * @property + * def itemsize(self): # <<<<<<<<<<<<<< + * return self.view.itemsize + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.itemsize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":592 + * + * @property + * def nbytes(self): # <<<<<<<<<<<<<< + * return self.size * self.view.itemsize + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":593 + * @property + * def nbytes(self): + * return self.size * self.view.itemsize # <<<<<<<<<<<<<< + * + * @property + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":592 + * + * @property + * def nbytes(self): # <<<<<<<<<<<<<< + * return self.size * self.view.itemsize + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.nbytes.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":596 + * + * @property + * def size(self): # <<<<<<<<<<<<<< + * if self._size is None: + * result = 1 + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_v_length = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":597 + * @property + * def size(self): + * if self._size is None: # <<<<<<<<<<<<<< + * result = 1 + * + */ + __pyx_t_1 = (__pyx_v_self->_size == Py_None); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":598 + * def size(self): + * if self._size is None: + * result = 1 # <<<<<<<<<<<<<< + * + * for length in self.view.shape[:self.view.ndim]: + */ + __Pyx_INCREF(__pyx_int_1); + __pyx_v_result = __pyx_int_1; + + /* "View.MemoryView":600 + * result = 1 + * + * for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<< + * result *= length + * + */ + __pyx_t_4 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); + for (__pyx_t_5 = __pyx_v_self->view.shape; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { + __pyx_t_3 = __pyx_t_5; + __pyx_t_6 = PyInt_FromSsize_t((__pyx_t_3[0])); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_6); + __pyx_t_6 = 0; + + /* "View.MemoryView":601 + * + * for length in self.view.shape[:self.view.ndim]: + * result *= length # <<<<<<<<<<<<<< + * + * self._size = result + */ + __pyx_t_6 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_6); + __pyx_t_6 = 0; + } + + /* "View.MemoryView":603 + * result *= length + * + * self._size = result # <<<<<<<<<<<<<< + * + * return self._size + */ + __Pyx_INCREF(__pyx_v_result); + __Pyx_GIVEREF(__pyx_v_result); + __Pyx_GOTREF(__pyx_v_self->_size); + __Pyx_DECREF(__pyx_v_self->_size); + __pyx_v_self->_size = __pyx_v_result; + + /* "View.MemoryView":597 + * @property + * def size(self): + * if self._size is None: # <<<<<<<<<<<<<< + * result = 1 + * + */ + } + + /* "View.MemoryView":605 + * self._size = result + * + * return self._size # <<<<<<<<<<<<<< + * + * def __len__(self): + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_size); + __pyx_r = __pyx_v_self->_size; + goto __pyx_L0; + + /* "View.MemoryView":596 + * + * @property + * def size(self): # <<<<<<<<<<<<<< + * if self._size is None: + * result = 1 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView.memoryview.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_length); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":607 + * return self._size + * + * def __len__(self): # <<<<<<<<<<<<<< + * if self.view.ndim >= 1: + * return self.view.shape[0] + */ + +/* Python wrapper */ +static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self); /*proto*/ +static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("__len__", 0); + + /* "View.MemoryView":608 + * + * def __len__(self): + * if self.view.ndim >= 1: # <<<<<<<<<<<<<< + * return self.view.shape[0] + * + */ + __pyx_t_1 = ((__pyx_v_self->view.ndim >= 1) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":609 + * def __len__(self): + * if self.view.ndim >= 1: + * return self.view.shape[0] # <<<<<<<<<<<<<< + * + * return 0 + */ + __pyx_r = (__pyx_v_self->view.shape[0]); + goto __pyx_L0; + + /* "View.MemoryView":608 + * + * def __len__(self): + * if self.view.ndim >= 1: # <<<<<<<<<<<<<< + * return self.view.shape[0] + * + */ + } + + /* "View.MemoryView":611 + * return self.view.shape[0] + * + * return 0 # <<<<<<<<<<<<<< + * + * def __repr__(self): + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":607 + * return self._size + * + * def __len__(self): # <<<<<<<<<<<<<< + * if self.view.ndim >= 1: + * return self.view.shape[0] + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":613 + * return 0 + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__, + * id(self)) + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "View.MemoryView":614 + * + * def __repr__(self): + * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< + * id(self)) + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":615 + * def __repr__(self): + * return "" % (self.base.__class__.__name__, + * id(self)) # <<<<<<<<<<<<<< + * + * def __str__(self): + */ + __pyx_t_2 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "View.MemoryView":614 + * + * def __repr__(self): + * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< + * id(self)) + * + */ + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":613 + * return 0 + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__, + * id(self)) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":617 + * id(self)) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__,) + * + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__str__", 0); + + /* "View.MemoryView":618 + * + * def __str__(self): + * return "" % (self.base.__class__.__name__,) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_n_s_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_n_s_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_n_s_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_MemoryView_of_r_object, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":617 + * id(self)) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__,) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":621 + * + * + * def is_c_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_c_contig (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice *__pyx_v_mslice; + __Pyx_memviewslice __pyx_v_tmp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_c_contig", 0); + + /* "View.MemoryView":624 + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< + * return slice_is_contig(mslice[0], 'C', self.view.ndim) + * + */ + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 624, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":625 + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) + * return slice_is_contig(mslice[0], 'C', self.view.ndim) # <<<<<<<<<<<<<< + * + * def is_f_contig(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'C', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":621 + * + * + * def is_c_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.is_c_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":627 + * return slice_is_contig(mslice[0], 'C', self.view.ndim) + * + * def is_f_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_f_contig (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice *__pyx_v_mslice; + __Pyx_memviewslice __pyx_v_tmp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_f_contig", 0); + + /* "View.MemoryView":630 + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< + * return slice_is_contig(mslice[0], 'F', self.view.ndim) + * + */ + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((__Pyx_memviewslice *)NULL))) __PYX_ERR(1, 630, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":631 + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) + * return slice_is_contig(mslice[0], 'F', self.view.ndim) # <<<<<<<<<<<<<< + * + * def copy(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'F', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":627 + * return slice_is_contig(mslice[0], 'C', self.view.ndim) + * + * def is_f_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.is_f_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":633 + * return slice_is_contig(mslice[0], 'F', self.view.ndim) + * + * def copy(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice mslice + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice __pyx_v_mslice; + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("copy", 0); + + /* "View.MemoryView":635 + * def copy(self): + * cdef __Pyx_memviewslice mslice + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS # <<<<<<<<<<<<<< + * + * slice_copy(self, &mslice) + */ + __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_F_CONTIGUOUS)); + + /* "View.MemoryView":637 + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS + * + * slice_copy(self, &mslice) # <<<<<<<<<<<<<< + * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, + * self.view.itemsize, + */ + __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_mslice)); + + /* "View.MemoryView":638 + * + * slice_copy(self, &mslice) + * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, # <<<<<<<<<<<<<< + * self.view.itemsize, + * flags|PyBUF_C_CONTIGUOUS, + */ + __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_mslice), ((char *)"c"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_C_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 638, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":643 + * self.dtype_is_object) + * + * return memoryview_copy_from_slice(self, &mslice) # <<<<<<<<<<<<<< + * + * def copy_fortran(self): + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_mslice)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 643, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":633 + * return slice_is_contig(mslice[0], 'F', self.view.ndim) + * + * def copy(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice mslice + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":645 + * return memoryview_copy_from_slice(self, &mslice) + * + * def copy_fortran(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice src, dst + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS + */ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy_fortran (wrapper)", 0); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice __pyx_v_src; + __Pyx_memviewslice __pyx_v_dst; + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("copy_fortran", 0); + + /* "View.MemoryView":647 + * def copy_fortran(self): + * cdef __Pyx_memviewslice src, dst + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS # <<<<<<<<<<<<<< + * + * slice_copy(self, &src) + */ + __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_C_CONTIGUOUS)); + + /* "View.MemoryView":649 + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS + * + * slice_copy(self, &src) # <<<<<<<<<<<<<< + * dst = slice_copy_contig(&src, "fortran", self.view.ndim, + * self.view.itemsize, + */ + __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_src)); + + /* "View.MemoryView":650 + * + * slice_copy(self, &src) + * dst = slice_copy_contig(&src, "fortran", self.view.ndim, # <<<<<<<<<<<<<< + * self.view.itemsize, + * flags|PyBUF_F_CONTIGUOUS, + */ + __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_src), ((char *)"fortran"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_F_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 650, __pyx_L1_error) + __pyx_v_dst = __pyx_t_1; + + /* "View.MemoryView":655 + * self.dtype_is_object) + * + * return memoryview_copy_from_slice(self, &dst) # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_dst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 655, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":645 + * return memoryview_copy_from_slice(self, &mslice) + * + * def copy_fortran(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice src, dst + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.copy_fortran", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_memoryview___reduce_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__13, 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__14, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":659 + * + * @cname('__pyx_memoryview_new') + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo + */ + +static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, int __pyx_v_dtype_is_object, __Pyx_TypeInfo *__pyx_v_typeinfo) { + struct __pyx_memoryview_obj *__pyx_v_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_cwrapper", 0); + + /* "View.MemoryView":660 + * @cname('__pyx_memoryview_new') + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): + * cdef memoryview result = memoryview(o, flags, dtype_is_object) # <<<<<<<<<<<<<< + * result.typeinfo = typeinfo + * return result + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_o); + __Pyx_GIVEREF(__pyx_v_o); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_o); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryview_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = ((struct __pyx_memoryview_obj *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":661 + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo # <<<<<<<<<<<<<< + * return result + * + */ + __pyx_v_result->typeinfo = __pyx_v_typeinfo; + + /* "View.MemoryView":662 + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo + * return result # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_check') + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "View.MemoryView":659 + * + * @cname('__pyx_memoryview_new') + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, __Pyx_TypeInfo *typeinfo): # <<<<<<<<<<<<<< + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":665 + * + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< + * return isinstance(o, memoryview) + * + */ + +static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("memoryview_check", 0); + + /* "View.MemoryView":666 + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): + * return isinstance(o, memoryview) # <<<<<<<<<<<<<< + * + * cdef tuple _unellipsify(object index, int ndim): + */ + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_o, __pyx_memoryview_type); + __pyx_r = __pyx_t_1; + goto __pyx_L0; + + /* "View.MemoryView":665 + * + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o): # <<<<<<<<<<<<<< + * return isinstance(o, memoryview) + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":668 + * return isinstance(o, memoryview) + * + * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< + * """ + * Replace all ellipses with full slices and fill incomplete indices with + */ + +static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { + PyObject *__pyx_v_tup = NULL; + PyObject *__pyx_v_result = NULL; + int __pyx_v_have_slices; + int __pyx_v_seen_ellipsis; + CYTHON_UNUSED PyObject *__pyx_v_idx = NULL; + PyObject *__pyx_v_item = NULL; + Py_ssize_t __pyx_v_nslices; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + Py_ssize_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + PyObject *__pyx_t_7 = NULL; + Py_ssize_t __pyx_t_8; + int __pyx_t_9; + int __pyx_t_10; + PyObject *__pyx_t_11 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_unellipsify", 0); + + /* "View.MemoryView":673 + * full slices. + * """ + * if not isinstance(index, tuple): # <<<<<<<<<<<<<< + * tup = (index,) + * else: + */ + __pyx_t_1 = PyTuple_Check(__pyx_v_index); + __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":674 + * """ + * if not isinstance(index, tuple): + * tup = (index,) # <<<<<<<<<<<<<< + * else: + * tup = index + */ + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 674, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_index); + __Pyx_GIVEREF(__pyx_v_index); + PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_index); + __pyx_v_tup = __pyx_t_3; + __pyx_t_3 = 0; + + /* "View.MemoryView":673 + * full slices. + * """ + * if not isinstance(index, tuple): # <<<<<<<<<<<<<< + * tup = (index,) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":676 + * tup = (index,) + * else: + * tup = index # <<<<<<<<<<<<<< + * + * result = [] + */ + /*else*/ { + __Pyx_INCREF(__pyx_v_index); + __pyx_v_tup = __pyx_v_index; + } + __pyx_L3:; + + /* "View.MemoryView":678 + * tup = index + * + * result = [] # <<<<<<<<<<<<<< + * have_slices = False + * seen_ellipsis = False + */ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 678, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_result = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":679 + * + * result = [] + * have_slices = False # <<<<<<<<<<<<<< + * seen_ellipsis = False + * for idx, item in enumerate(tup): + */ + __pyx_v_have_slices = 0; + + /* "View.MemoryView":680 + * result = [] + * have_slices = False + * seen_ellipsis = False # <<<<<<<<<<<<<< + * for idx, item in enumerate(tup): + * if item is Ellipsis: + */ + __pyx_v_seen_ellipsis = 0; + + /* "View.MemoryView":681 + * have_slices = False + * seen_ellipsis = False + * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< + * if item is Ellipsis: + * if not seen_ellipsis: + */ + __Pyx_INCREF(__pyx_int_0); + __pyx_t_3 = __pyx_int_0; + if (likely(PyList_CheckExact(__pyx_v_tup)) || PyTuple_CheckExact(__pyx_v_tup)) { + __pyx_t_4 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_4); __pyx_t_5 = 0; + __pyx_t_6 = NULL; + } else { + __pyx_t_5 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_v_tup); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = Py_TYPE(__pyx_t_4)->tp_iternext; if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 681, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_6)) { + if (likely(PyList_CheckExact(__pyx_t_4))) { + if (__pyx_t_5 >= PyList_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyList_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 681, __pyx_L1_error) + #else + __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } else { + if (__pyx_t_5 >= PyTuple_GET_SIZE(__pyx_t_4)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_7 = PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_5); __Pyx_INCREF(__pyx_t_7); __pyx_t_5++; if (unlikely(0 < 0)) __PYX_ERR(1, 681, __pyx_L1_error) + #else + __pyx_t_7 = PySequence_ITEM(__pyx_t_4, __pyx_t_5); __pyx_t_5++; if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + } + } else { + __pyx_t_7 = __pyx_t_6(__pyx_t_4); + if (unlikely(!__pyx_t_7)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 681, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_7); + } + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_INCREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_3); + __pyx_t_7 = __Pyx_PyInt_AddObjC(__pyx_t_3, __pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); + __pyx_t_3 = __pyx_t_7; + __pyx_t_7 = 0; + + /* "View.MemoryView":682 + * seen_ellipsis = False + * for idx, item in enumerate(tup): + * if item is Ellipsis: # <<<<<<<<<<<<<< + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + */ + __pyx_t_2 = (__pyx_v_item == __pyx_builtin_Ellipsis); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":683 + * for idx, item in enumerate(tup): + * if item is Ellipsis: + * if not seen_ellipsis: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True + */ + __pyx_t_1 = ((!(__pyx_v_seen_ellipsis != 0)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":684 + * if item is Ellipsis: + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<< + * seen_ellipsis = True + * else: + */ + __pyx_t_8 = PyObject_Length(__pyx_v_tup); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(1, 684, __pyx_L1_error) + __pyx_t_7 = PyList_New(1 * ((((__pyx_v_ndim - __pyx_t_8) + 1)<0) ? 0:((__pyx_v_ndim - __pyx_t_8) + 1))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 684, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < ((__pyx_v_ndim - __pyx_t_8) + 1); __pyx_temp++) { + __Pyx_INCREF(__pyx_slice__15); + __Pyx_GIVEREF(__pyx_slice__15); + PyList_SET_ITEM(__pyx_t_7, __pyx_temp, __pyx_slice__15); + } + } + __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_7); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 684, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "View.MemoryView":685 + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True # <<<<<<<<<<<<<< + * else: + * result.append(slice(None)) + */ + __pyx_v_seen_ellipsis = 1; + + /* "View.MemoryView":683 + * for idx, item in enumerate(tup): + * if item is Ellipsis: + * if not seen_ellipsis: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + * seen_ellipsis = True + */ + goto __pyx_L7; + } + + /* "View.MemoryView":687 + * seen_ellipsis = True + * else: + * result.append(slice(None)) # <<<<<<<<<<<<<< + * have_slices = True + * else: + */ + /*else*/ { + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_slice__15); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 687, __pyx_L1_error) + } + __pyx_L7:; + + /* "View.MemoryView":688 + * else: + * result.append(slice(None)) + * have_slices = True # <<<<<<<<<<<<<< + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): + */ + __pyx_v_have_slices = 1; + + /* "View.MemoryView":682 + * seen_ellipsis = False + * for idx, item in enumerate(tup): + * if item is Ellipsis: # <<<<<<<<<<<<<< + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) + */ + goto __pyx_L6; + } + + /* "View.MemoryView":690 + * have_slices = True + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + */ + /*else*/ { + __pyx_t_2 = PySlice_Check(__pyx_v_item); + __pyx_t_10 = ((!(__pyx_t_2 != 0)) != 0); + if (__pyx_t_10) { + } else { + __pyx_t_1 = __pyx_t_10; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_10 = ((!(PyIndex_Check(__pyx_v_item) != 0)) != 0); + __pyx_t_1 = __pyx_t_10; + __pyx_L9_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":691 + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): + * raise TypeError("Cannot index with type '%s'" % type(item)) # <<<<<<<<<<<<<< + * + * have_slices = have_slices or isinstance(item, slice) + */ + __pyx_t_7 = __Pyx_PyString_FormatSafe(__pyx_kp_s_Cannot_index_with_type_s, ((PyObject *)Py_TYPE(__pyx_v_item))); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_11 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_7); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_Raise(__pyx_t_11, 0, 0, 0); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __PYX_ERR(1, 691, __pyx_L1_error) + + /* "View.MemoryView":690 + * have_slices = True + * else: + * if not isinstance(item, slice) and not PyIndex_Check(item): # <<<<<<<<<<<<<< + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + */ + } + + /* "View.MemoryView":693 + * raise TypeError("Cannot index with type '%s'" % type(item)) + * + * have_slices = have_slices or isinstance(item, slice) # <<<<<<<<<<<<<< + * result.append(item) + * + */ + __pyx_t_10 = (__pyx_v_have_slices != 0); + if (!__pyx_t_10) { + } else { + __pyx_t_1 = __pyx_t_10; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_10 = PySlice_Check(__pyx_v_item); + __pyx_t_2 = (__pyx_t_10 != 0); + __pyx_t_1 = __pyx_t_2; + __pyx_L11_bool_binop_done:; + __pyx_v_have_slices = __pyx_t_1; + + /* "View.MemoryView":694 + * + * have_slices = have_slices or isinstance(item, slice) + * result.append(item) # <<<<<<<<<<<<<< + * + * nslices = ndim - len(result) + */ + __pyx_t_9 = __Pyx_PyList_Append(__pyx_v_result, __pyx_v_item); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 694, __pyx_L1_error) + } + __pyx_L6:; + + /* "View.MemoryView":681 + * have_slices = False + * seen_ellipsis = False + * for idx, item in enumerate(tup): # <<<<<<<<<<<<<< + * if item is Ellipsis: + * if not seen_ellipsis: + */ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":696 + * result.append(item) + * + * nslices = ndim - len(result) # <<<<<<<<<<<<<< + * if nslices: + * result.extend([slice(None)] * nslices) + */ + __pyx_t_5 = PyList_GET_SIZE(__pyx_v_result); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 696, __pyx_L1_error) + __pyx_v_nslices = (__pyx_v_ndim - __pyx_t_5); + + /* "View.MemoryView":697 + * + * nslices = ndim - len(result) + * if nslices: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * nslices) + * + */ + __pyx_t_1 = (__pyx_v_nslices != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":698 + * nslices = ndim - len(result) + * if nslices: + * result.extend([slice(None)] * nslices) # <<<<<<<<<<<<<< + * + * return have_slices or nslices, tuple(result) + */ + __pyx_t_3 = PyList_New(1 * ((__pyx_v_nslices<0) ? 0:__pyx_v_nslices)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 698, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < __pyx_v_nslices; __pyx_temp++) { + __Pyx_INCREF(__pyx_slice__15); + __Pyx_GIVEREF(__pyx_slice__15); + PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_slice__15); + } + } + __pyx_t_9 = __Pyx_PyList_Extend(__pyx_v_result, __pyx_t_3); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 698, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":697 + * + * nslices = ndim - len(result) + * if nslices: # <<<<<<<<<<<<<< + * result.extend([slice(None)] * nslices) + * + */ + } + + /* "View.MemoryView":700 + * result.extend([slice(None)] * nslices) + * + * return have_slices or nslices, tuple(result) # <<<<<<<<<<<<<< + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + */ + __Pyx_XDECREF(__pyx_r); + if (!__pyx_v_have_slices) { + } else { + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L14_bool_binop_done; + } + __pyx_t_4 = PyInt_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_L14_bool_binop_done:; + __pyx_t_4 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_11 = PyTuple_New(2); if (unlikely(!__pyx_t_11)) __PYX_ERR(1, 700, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_11, 0, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + PyTuple_SET_ITEM(__pyx_t_11, 1, __pyx_t_4); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_r = ((PyObject*)__pyx_t_11); + __pyx_t_11 = 0; + goto __pyx_L0; + + /* "View.MemoryView":668 + * return isinstance(o, memoryview) + * + * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< + * """ + * Replace all ellipses with full slices and fill incomplete indices with + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_AddTraceback("View.MemoryView._unellipsify", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_tup); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_idx); + __Pyx_XDECREF(__pyx_v_item); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":702 + * return have_slices or nslices, tuple(result) + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + */ + +static PyObject *assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __pyx_v_ndim) { + Py_ssize_t __pyx_v_suboffset; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + Py_ssize_t *__pyx_t_1; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("assert_direct_dimensions", 0); + + /* "View.MemoryView":703 + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * for suboffset in suboffsets[:ndim]: # <<<<<<<<<<<<<< + * if suboffset >= 0: + * raise ValueError("Indirect dimensions not supported") + */ + __pyx_t_2 = (__pyx_v_suboffsets + __pyx_v_ndim); + for (__pyx_t_3 = __pyx_v_suboffsets; __pyx_t_3 < __pyx_t_2; __pyx_t_3++) { + __pyx_t_1 = __pyx_t_3; + __pyx_v_suboffset = (__pyx_t_1[0]); + + /* "View.MemoryView":704 + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * raise ValueError("Indirect dimensions not supported") + * + */ + __pyx_t_4 = ((__pyx_v_suboffset >= 0) != 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":705 + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + * raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __Pyx_PyObject_Call(__pyx_builtin_ValueError, __pyx_tuple__16, NULL); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(1, 705, __pyx_L1_error) + + /* "View.MemoryView":704 + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * raise ValueError("Indirect dimensions not supported") + * + */ + } + } + + /* "View.MemoryView":702 + * return have_slices or nslices, tuple(result) + * + * cdef assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim): # <<<<<<<<<<<<<< + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.assert_direct_dimensions", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":712 + * + * @cname('__pyx_memview_slice') + * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< + * cdef int new_ndim = 0, suboffset_dim = -1, dim + * cdef bint negative_step + */ + +static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *__pyx_v_memview, PyObject *__pyx_v_indices) { + int __pyx_v_new_ndim; + int __pyx_v_suboffset_dim; + int __pyx_v_dim; + __Pyx_memviewslice __pyx_v_src; + __Pyx_memviewslice __pyx_v_dst; + __Pyx_memviewslice *__pyx_v_p_src; + struct __pyx_memoryviewslice_obj *__pyx_v_memviewsliceobj = 0; + __Pyx_memviewslice *__pyx_v_p_dst; + int *__pyx_v_p_suboffset_dim; + Py_ssize_t __pyx_v_start; + Py_ssize_t __pyx_v_stop; + Py_ssize_t __pyx_v_step; + int __pyx_v_have_start; + int __pyx_v_have_stop; + int __pyx_v_have_step; + PyObject *__pyx_v_index = NULL; + struct __pyx_memoryview_obj *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + struct __pyx_memoryview_obj *__pyx_t_4; + char *__pyx_t_5; + int __pyx_t_6; + Py_ssize_t __pyx_t_7; + PyObject *(*__pyx_t_8)(PyObject *); + PyObject *__pyx_t_9 = NULL; + Py_ssize_t __pyx_t_10; + int __pyx_t_11; + Py_ssize_t __pyx_t_12; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memview_slice", 0); + + /* "View.MemoryView":713 + * @cname('__pyx_memview_slice') + * cdef memoryview memview_slice(memoryview memview, object indices): + * cdef int new_ndim = 0, suboffset_dim = -1, dim # <<<<<<<<<<<<<< + * cdef bint negative_step + * cdef __Pyx_memviewslice src, dst + */ + __pyx_v_new_ndim = 0; + __pyx_v_suboffset_dim = -1; + + /* "View.MemoryView":720 + * + * + * memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<< + * + * cdef _memoryviewslice memviewsliceobj + */ + (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst)))); + + /* "View.MemoryView":724 + * cdef _memoryviewslice memviewsliceobj + * + * assert memview.view.ndim > 0 # <<<<<<<<<<<<<< + * + * if isinstance(memview, _memoryviewslice): + */ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(!Py_OptimizeFlag)) { + if (unlikely(!((__pyx_v_memview->view.ndim > 0) != 0))) { + PyErr_SetNone(PyExc_AssertionError); + __PYX_ERR(1, 724, __pyx_L1_error) + } + } + #endif + + /* "View.MemoryView":726 + * assert memview.view.ndim > 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":727 + * + * if isinstance(memview, _memoryviewslice): + * memviewsliceobj = memview # <<<<<<<<<<<<<< + * p_src = &memviewsliceobj.from_slice + * else: + */ + if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 727, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_v_memview); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":728 + * if isinstance(memview, _memoryviewslice): + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice # <<<<<<<<<<<<<< + * else: + * slice_copy(memview, &src) + */ + __pyx_v_p_src = (&__pyx_v_memviewsliceobj->from_slice); + + /* "View.MemoryView":726 + * assert memview.view.ndim > 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice + */ + goto __pyx_L3; + } + + /* "View.MemoryView":730 + * p_src = &memviewsliceobj.from_slice + * else: + * slice_copy(memview, &src) # <<<<<<<<<<<<<< + * p_src = &src + * + */ + /*else*/ { + __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_src)); + + /* "View.MemoryView":731 + * else: + * slice_copy(memview, &src) + * p_src = &src # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_p_src = (&__pyx_v_src); + } + __pyx_L3:; + + /* "View.MemoryView":737 + * + * + * dst.memview = p_src.memview # <<<<<<<<<<<<<< + * dst.data = p_src.data + * + */ + __pyx_t_4 = __pyx_v_p_src->memview; + __pyx_v_dst.memview = __pyx_t_4; + + /* "View.MemoryView":738 + * + * dst.memview = p_src.memview + * dst.data = p_src.data # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __pyx_v_p_src->data; + __pyx_v_dst.data = __pyx_t_5; + + /* "View.MemoryView":743 + * + * + * cdef __Pyx_memviewslice *p_dst = &dst # <<<<<<<<<<<<<< + * cdef int *p_suboffset_dim = &suboffset_dim + * cdef Py_ssize_t start, stop, step + */ + __pyx_v_p_dst = (&__pyx_v_dst); + + /* "View.MemoryView":744 + * + * cdef __Pyx_memviewslice *p_dst = &dst + * cdef int *p_suboffset_dim = &suboffset_dim # <<<<<<<<<<<<<< + * cdef Py_ssize_t start, stop, step + * cdef bint have_start, have_stop, have_step + */ + __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim); + + /* "View.MemoryView":748 + * cdef bint have_start, have_stop, have_step + * + * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< + * if PyIndex_Check(index): + * slice_memviewslice( + */ + __pyx_t_6 = 0; + if (likely(PyList_CheckExact(__pyx_v_indices)) || PyTuple_CheckExact(__pyx_v_indices)) { + __pyx_t_3 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_3); __pyx_t_7 = 0; + __pyx_t_8 = NULL; + } else { + __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = Py_TYPE(__pyx_t_3)->tp_iternext; if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 748, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_8)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + if (__pyx_t_7 >= PyList_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_9 = PyList_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(1, 748, __pyx_L1_error) + #else + __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + } else { + if (__pyx_t_7 >= PyTuple_GET_SIZE(__pyx_t_3)) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_9 = PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7); __Pyx_INCREF(__pyx_t_9); __pyx_t_7++; if (unlikely(0 < 0)) __PYX_ERR(1, 748, __pyx_L1_error) + #else + __pyx_t_9 = PySequence_ITEM(__pyx_t_3, __pyx_t_7); __pyx_t_7++; if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + } + } else { + __pyx_t_9 = __pyx_t_8(__pyx_t_3); + if (unlikely(!__pyx_t_9)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) PyErr_Clear(); + else __PYX_ERR(1, 748, __pyx_L1_error) + } + break; + } + __Pyx_GOTREF(__pyx_t_9); + } + __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_9); + __pyx_t_9 = 0; + __pyx_v_dim = __pyx_t_6; + __pyx_t_6 = (__pyx_t_6 + 1); + + /* "View.MemoryView":749 + * + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): # <<<<<<<<<<<<<< + * slice_memviewslice( + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + */ + __pyx_t_2 = (PyIndex_Check(__pyx_v_index) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":753 + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + * dim, new_ndim, p_suboffset_dim, + * index, 0, 0, # start, stop, step # <<<<<<<<<<<<<< + * 0, 0, 0, # have_{start,stop,step} + * False) + */ + __pyx_t_10 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_10 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 753, __pyx_L1_error) + + /* "View.MemoryView":750 + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): + * slice_memviewslice( # <<<<<<<<<<<<<< + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + * dim, new_ndim, p_suboffset_dim, + */ + __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_t_10, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 750, __pyx_L1_error) + + /* "View.MemoryView":749 + * + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): # <<<<<<<<<<<<<< + * slice_memviewslice( + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + */ + goto __pyx_L6; + } + + /* "View.MemoryView":756 + * 0, 0, 0, # have_{start,stop,step} + * False) + * elif index is None: # <<<<<<<<<<<<<< + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 + */ + __pyx_t_2 = (__pyx_v_index == Py_None); + __pyx_t_1 = (__pyx_t_2 != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":757 + * False) + * elif index is None: + * p_dst.shape[new_ndim] = 1 # <<<<<<<<<<<<<< + * p_dst.strides[new_ndim] = 0 + * p_dst.suboffsets[new_ndim] = -1 + */ + (__pyx_v_p_dst->shape[__pyx_v_new_ndim]) = 1; + + /* "View.MemoryView":758 + * elif index is None: + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 # <<<<<<<<<<<<<< + * p_dst.suboffsets[new_ndim] = -1 + * new_ndim += 1 + */ + (__pyx_v_p_dst->strides[__pyx_v_new_ndim]) = 0; + + /* "View.MemoryView":759 + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 + * p_dst.suboffsets[new_ndim] = -1 # <<<<<<<<<<<<<< + * new_ndim += 1 + * else: + */ + (__pyx_v_p_dst->suboffsets[__pyx_v_new_ndim]) = -1L; + + /* "View.MemoryView":760 + * p_dst.strides[new_ndim] = 0 + * p_dst.suboffsets[new_ndim] = -1 + * new_ndim += 1 # <<<<<<<<<<<<<< + * else: + * start = index.start or 0 + */ + __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); + + /* "View.MemoryView":756 + * 0, 0, 0, # have_{start,stop,step} + * False) + * elif index is None: # <<<<<<<<<<<<<< + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 + */ + goto __pyx_L6; + } + + /* "View.MemoryView":762 + * new_ndim += 1 + * else: + * start = index.start or 0 # <<<<<<<<<<<<<< + * stop = index.stop or 0 + * step = index.step or 0 + */ + /*else*/ { + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 762, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 762, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 762, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L7_bool_binop_done:; + __pyx_v_start = __pyx_t_10; + + /* "View.MemoryView":763 + * else: + * start = index.start or 0 + * stop = index.stop or 0 # <<<<<<<<<<<<<< + * step = index.step or 0 + * + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 763, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 763, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 763, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L9_bool_binop_done:; + __pyx_v_stop = __pyx_t_10; + + /* "View.MemoryView":764 + * start = index.start or 0 + * stop = index.stop or 0 + * step = index.step or 0 # <<<<<<<<<<<<<< + * + * have_start = index.start is not None + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 764, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_9); if (unlikely(__pyx_t_1 < 0)) __PYX_ERR(1, 764, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + } else { + __pyx_t_12 = __Pyx_PyIndex_AsSsize_t(__pyx_t_9); if (unlikely((__pyx_t_12 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 764, __pyx_L1_error) + __pyx_t_10 = __pyx_t_12; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_10 = 0; + __pyx_L11_bool_binop_done:; + __pyx_v_step = __pyx_t_10; + + /* "View.MemoryView":766 + * step = index.step or 0 + * + * have_start = index.start is not None # <<<<<<<<<<<<<< + * have_stop = index.stop is not None + * have_step = index.step is not None + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_start); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 766, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_have_start = __pyx_t_1; + + /* "View.MemoryView":767 + * + * have_start = index.start is not None + * have_stop = index.stop is not None # <<<<<<<<<<<<<< + * have_step = index.step is not None + * + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_stop); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 767, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_have_stop = __pyx_t_1; + + /* "View.MemoryView":768 + * have_start = index.start is not None + * have_stop = index.stop is not None + * have_step = index.step is not None # <<<<<<<<<<<<<< + * + * slice_memviewslice( + */ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_n_s_step); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 768, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = (__pyx_t_9 != Py_None); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_have_step = __pyx_t_1; + + /* "View.MemoryView":770 + * have_step = index.step is not None + * + * slice_memviewslice( # <<<<<<<<<<<<<< + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + * dim, new_ndim, p_suboffset_dim, + */ + __pyx_t_11 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_start, __pyx_v_stop, __pyx_v_step, __pyx_v_have_start, __pyx_v_have_stop, __pyx_v_have_step, 1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(1, 770, __pyx_L1_error) + + /* "View.MemoryView":776 + * have_start, have_stop, have_step, + * True) + * new_ndim += 1 # <<<<<<<<<<<<<< + * + * if isinstance(memview, _memoryviewslice): + */ + __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); + } + __pyx_L6:; + + /* "View.MemoryView":748 + * cdef bint have_start, have_stop, have_step + * + * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< + * if PyIndex_Check(index): + * slice_memviewslice( + */ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":778 + * new_ndim += 1 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":779 + * + * if isinstance(memview, _memoryviewslice): + * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< + * memviewsliceobj.to_object_func, + * memviewsliceobj.to_dtype_func, + */ + __Pyx_XDECREF(((PyObject *)__pyx_r)); + + /* "View.MemoryView":780 + * if isinstance(memview, _memoryviewslice): + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, # <<<<<<<<<<<<<< + * memviewsliceobj.to_dtype_func, + * memview.dtype_is_object) + */ + if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 780, __pyx_L1_error) } + + /* "View.MemoryView":781 + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, + * memviewsliceobj.to_dtype_func, # <<<<<<<<<<<<<< + * memview.dtype_is_object) + * else: + */ + if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 781, __pyx_L1_error) } + + /* "View.MemoryView":779 + * + * if isinstance(memview, _memoryviewslice): + * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< + * memviewsliceobj.to_object_func, + * memviewsliceobj.to_dtype_func, + */ + __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, __pyx_v_memviewsliceobj->to_object_func, __pyx_v_memviewsliceobj->to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 779, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 779, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":778 + * new_ndim += 1 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, + */ + } + + /* "View.MemoryView":784 + * memview.dtype_is_object) + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< + * memview.dtype_is_object) + * + */ + /*else*/ { + __Pyx_XDECREF(((PyObject *)__pyx_r)); + + /* "View.MemoryView":785 + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, + * memview.dtype_is_object) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 784, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "View.MemoryView":784 + * memview.dtype_is_object) + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< + * memview.dtype_is_object) + * + */ + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_memoryview_type))))) __PYX_ERR(1, 784, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":712 + * + * @cname('__pyx_memview_slice') + * cdef memoryview memview_slice(memoryview memview, object indices): # <<<<<<<<<<<<<< + * cdef int new_ndim = 0, suboffset_dim = -1, dim + * cdef bint negative_step + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("View.MemoryView.memview_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_memviewsliceobj); + __Pyx_XDECREF(__pyx_v_index); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":809 + * + * @cname('__pyx_memoryview_slice_memviewslice') + * cdef int slice_memviewslice( # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, + */ + +static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, Py_ssize_t __pyx_v_shape, Py_ssize_t __pyx_v_stride, Py_ssize_t __pyx_v_suboffset, int __pyx_v_dim, int __pyx_v_new_ndim, int *__pyx_v_suboffset_dim, Py_ssize_t __pyx_v_start, Py_ssize_t __pyx_v_stop, Py_ssize_t __pyx_v_step, int __pyx_v_have_start, int __pyx_v_have_stop, int __pyx_v_have_step, int __pyx_v_is_slice) { + Py_ssize_t __pyx_v_new_shape; + int __pyx_v_negative_step; + int __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":829 + * cdef bint negative_step + * + * if not is_slice: # <<<<<<<<<<<<<< + * + * if start < 0: + */ + __pyx_t_1 = ((!(__pyx_v_is_slice != 0)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":831 + * if not is_slice: + * + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if not 0 <= start < shape: + */ + __pyx_t_1 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":832 + * + * if start < 0: + * start += shape # <<<<<<<<<<<<<< + * if not 0 <= start < shape: + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + */ + __pyx_v_start = (__pyx_v_start + __pyx_v_shape); + + /* "View.MemoryView":831 + * if not is_slice: + * + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if not 0 <= start < shape: + */ + } + + /* "View.MemoryView":833 + * if start < 0: + * start += shape + * if not 0 <= start < shape: # <<<<<<<<<<<<<< + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + * else: + */ + __pyx_t_1 = (0 <= __pyx_v_start); + if (__pyx_t_1) { + __pyx_t_1 = (__pyx_v_start < __pyx_v_shape); + } + __pyx_t_2 = ((!(__pyx_t_1 != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":834 + * start += shape + * if not 0 <= start < shape: + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) # <<<<<<<<<<<<<< + * else: + * + */ + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"Index out of bounds (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 834, __pyx_L1_error) + + /* "View.MemoryView":833 + * if start < 0: + * start += shape + * if not 0 <= start < shape: # <<<<<<<<<<<<<< + * _err_dim(IndexError, "Index out of bounds (axis %d)", dim) + * else: + */ + } + + /* "View.MemoryView":829 + * cdef bint negative_step + * + * if not is_slice: # <<<<<<<<<<<<<< + * + * if start < 0: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":837 + * else: + * + * negative_step = have_step != 0 and step < 0 # <<<<<<<<<<<<<< + * + * if have_step and step == 0: + */ + /*else*/ { + __pyx_t_1 = ((__pyx_v_have_step != 0) != 0); + if (__pyx_t_1) { + } else { + __pyx_t_2 = __pyx_t_1; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_1 = ((__pyx_v_step < 0) != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L6_bool_binop_done:; + __pyx_v_negative_step = __pyx_t_2; + + /* "View.MemoryView":839 + * negative_step = have_step != 0 and step < 0 + * + * if have_step and step == 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) + * + */ + __pyx_t_1 = (__pyx_v_have_step != 0); + if (__pyx_t_1) { + } else { + __pyx_t_2 = __pyx_t_1; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_1 = ((__pyx_v_step == 0) != 0); + __pyx_t_2 = __pyx_t_1; + __pyx_L9_bool_binop_done:; + if (__pyx_t_2) { + + /* "View.MemoryView":840 + * + * if have_step and step == 0: + * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Step may not be zero (axis %d)"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 840, __pyx_L1_error) + + /* "View.MemoryView":839 + * negative_step = have_step != 0 and step < 0 + * + * if have_step and step == 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Step may not be zero (axis %d)", dim) + * + */ + } + + /* "View.MemoryView":843 + * + * + * if have_start: # <<<<<<<<<<<<<< + * if start < 0: + * start += shape + */ + __pyx_t_2 = (__pyx_v_have_start != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":844 + * + * if have_start: + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if start < 0: + */ + __pyx_t_2 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":845 + * if have_start: + * if start < 0: + * start += shape # <<<<<<<<<<<<<< + * if start < 0: + * start = 0 + */ + __pyx_v_start = (__pyx_v_start + __pyx_v_shape); + + /* "View.MemoryView":846 + * if start < 0: + * start += shape + * if start < 0: # <<<<<<<<<<<<<< + * start = 0 + * elif start >= shape: + */ + __pyx_t_2 = ((__pyx_v_start < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":847 + * start += shape + * if start < 0: + * start = 0 # <<<<<<<<<<<<<< + * elif start >= shape: + * if negative_step: + */ + __pyx_v_start = 0; + + /* "View.MemoryView":846 + * if start < 0: + * start += shape + * if start < 0: # <<<<<<<<<<<<<< + * start = 0 + * elif start >= shape: + */ + } + + /* "View.MemoryView":844 + * + * if have_start: + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if start < 0: + */ + goto __pyx_L12; + } + + /* "View.MemoryView":848 + * if start < 0: + * start = 0 + * elif start >= shape: # <<<<<<<<<<<<<< + * if negative_step: + * start = shape - 1 + */ + __pyx_t_2 = ((__pyx_v_start >= __pyx_v_shape) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":849 + * start = 0 + * elif start >= shape: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":850 + * elif start >= shape: + * if negative_step: + * start = shape - 1 # <<<<<<<<<<<<<< + * else: + * start = shape + */ + __pyx_v_start = (__pyx_v_shape - 1); + + /* "View.MemoryView":849 + * start = 0 + * elif start >= shape: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + goto __pyx_L14; + } + + /* "View.MemoryView":852 + * start = shape - 1 + * else: + * start = shape # <<<<<<<<<<<<<< + * else: + * if negative_step: + */ + /*else*/ { + __pyx_v_start = __pyx_v_shape; + } + __pyx_L14:; + + /* "View.MemoryView":848 + * if start < 0: + * start = 0 + * elif start >= shape: # <<<<<<<<<<<<<< + * if negative_step: + * start = shape - 1 + */ + } + __pyx_L12:; + + /* "View.MemoryView":843 + * + * + * if have_start: # <<<<<<<<<<<<<< + * if start < 0: + * start += shape + */ + goto __pyx_L11; + } + + /* "View.MemoryView":854 + * start = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + /*else*/ { + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":855 + * else: + * if negative_step: + * start = shape - 1 # <<<<<<<<<<<<<< + * else: + * start = 0 + */ + __pyx_v_start = (__pyx_v_shape - 1); + + /* "View.MemoryView":854 + * start = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: + */ + goto __pyx_L15; + } + + /* "View.MemoryView":857 + * start = shape - 1 + * else: + * start = 0 # <<<<<<<<<<<<<< + * + * if have_stop: + */ + /*else*/ { + __pyx_v_start = 0; + } + __pyx_L15:; + } + __pyx_L11:; + + /* "View.MemoryView":859 + * start = 0 + * + * if have_stop: # <<<<<<<<<<<<<< + * if stop < 0: + * stop += shape + */ + __pyx_t_2 = (__pyx_v_have_stop != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":860 + * + * if have_stop: + * if stop < 0: # <<<<<<<<<<<<<< + * stop += shape + * if stop < 0: + */ + __pyx_t_2 = ((__pyx_v_stop < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":861 + * if have_stop: + * if stop < 0: + * stop += shape # <<<<<<<<<<<<<< + * if stop < 0: + * stop = 0 + */ + __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape); + + /* "View.MemoryView":862 + * if stop < 0: + * stop += shape + * if stop < 0: # <<<<<<<<<<<<<< + * stop = 0 + * elif stop > shape: + */ + __pyx_t_2 = ((__pyx_v_stop < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":863 + * stop += shape + * if stop < 0: + * stop = 0 # <<<<<<<<<<<<<< + * elif stop > shape: + * stop = shape + */ + __pyx_v_stop = 0; + + /* "View.MemoryView":862 + * if stop < 0: + * stop += shape + * if stop < 0: # <<<<<<<<<<<<<< + * stop = 0 + * elif stop > shape: + */ + } + + /* "View.MemoryView":860 + * + * if have_stop: + * if stop < 0: # <<<<<<<<<<<<<< + * stop += shape + * if stop < 0: + */ + goto __pyx_L17; + } + + /* "View.MemoryView":864 + * if stop < 0: + * stop = 0 + * elif stop > shape: # <<<<<<<<<<<<<< + * stop = shape + * else: + */ + __pyx_t_2 = ((__pyx_v_stop > __pyx_v_shape) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":865 + * stop = 0 + * elif stop > shape: + * stop = shape # <<<<<<<<<<<<<< + * else: + * if negative_step: + */ + __pyx_v_stop = __pyx_v_shape; + + /* "View.MemoryView":864 + * if stop < 0: + * stop = 0 + * elif stop > shape: # <<<<<<<<<<<<<< + * stop = shape + * else: + */ + } + __pyx_L17:; + + /* "View.MemoryView":859 + * start = 0 + * + * if have_stop: # <<<<<<<<<<<<<< + * if stop < 0: + * stop += shape + */ + goto __pyx_L16; + } + + /* "View.MemoryView":867 + * stop = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * stop = -1 + * else: + */ + /*else*/ { + __pyx_t_2 = (__pyx_v_negative_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":868 + * else: + * if negative_step: + * stop = -1 # <<<<<<<<<<<<<< + * else: + * stop = shape + */ + __pyx_v_stop = -1L; + + /* "View.MemoryView":867 + * stop = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * stop = -1 + * else: + */ + goto __pyx_L19; + } + + /* "View.MemoryView":870 + * stop = -1 + * else: + * stop = shape # <<<<<<<<<<<<<< + * + * if not have_step: + */ + /*else*/ { + __pyx_v_stop = __pyx_v_shape; + } + __pyx_L19:; + } + __pyx_L16:; + + /* "View.MemoryView":872 + * stop = shape + * + * if not have_step: # <<<<<<<<<<<<<< + * step = 1 + * + */ + __pyx_t_2 = ((!(__pyx_v_have_step != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":873 + * + * if not have_step: + * step = 1 # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_step = 1; + + /* "View.MemoryView":872 + * stop = shape + * + * if not have_step: # <<<<<<<<<<<<<< + * step = 1 + * + */ + } + + /* "View.MemoryView":877 + * + * with cython.cdivision(True): + * new_shape = (stop - start) // step # <<<<<<<<<<<<<< + * + * if (stop - start) - step * new_shape: + */ + __pyx_v_new_shape = ((__pyx_v_stop - __pyx_v_start) / __pyx_v_step); + + /* "View.MemoryView":879 + * new_shape = (stop - start) // step + * + * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< + * new_shape += 1 + * + */ + __pyx_t_2 = (((__pyx_v_stop - __pyx_v_start) - (__pyx_v_step * __pyx_v_new_shape)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":880 + * + * if (stop - start) - step * new_shape: + * new_shape += 1 # <<<<<<<<<<<<<< + * + * if new_shape < 0: + */ + __pyx_v_new_shape = (__pyx_v_new_shape + 1); + + /* "View.MemoryView":879 + * new_shape = (stop - start) // step + * + * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< + * new_shape += 1 + * + */ + } + + /* "View.MemoryView":882 + * new_shape += 1 + * + * if new_shape < 0: # <<<<<<<<<<<<<< + * new_shape = 0 + * + */ + __pyx_t_2 = ((__pyx_v_new_shape < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":883 + * + * if new_shape < 0: + * new_shape = 0 # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_new_shape = 0; + + /* "View.MemoryView":882 + * new_shape += 1 + * + * if new_shape < 0: # <<<<<<<<<<<<<< + * new_shape = 0 + * + */ + } + + /* "View.MemoryView":886 + * + * + * dst.strides[new_ndim] = stride * step # <<<<<<<<<<<<<< + * dst.shape[new_ndim] = new_shape + * dst.suboffsets[new_ndim] = suboffset + */ + (__pyx_v_dst->strides[__pyx_v_new_ndim]) = (__pyx_v_stride * __pyx_v_step); + + /* "View.MemoryView":887 + * + * dst.strides[new_ndim] = stride * step + * dst.shape[new_ndim] = new_shape # <<<<<<<<<<<<<< + * dst.suboffsets[new_ndim] = suboffset + * + */ + (__pyx_v_dst->shape[__pyx_v_new_ndim]) = __pyx_v_new_shape; + + /* "View.MemoryView":888 + * dst.strides[new_ndim] = stride * step + * dst.shape[new_ndim] = new_shape + * dst.suboffsets[new_ndim] = suboffset # <<<<<<<<<<<<<< + * + * + */ + (__pyx_v_dst->suboffsets[__pyx_v_new_ndim]) = __pyx_v_suboffset; + } + __pyx_L3:; + + /* "View.MemoryView":891 + * + * + * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< + * dst.data += start * stride + * else: + */ + __pyx_t_2 = (((__pyx_v_suboffset_dim[0]) < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":892 + * + * if suboffset_dim[0] < 0: + * dst.data += start * stride # <<<<<<<<<<<<<< + * else: + * dst.suboffsets[suboffset_dim[0]] += start * stride + */ + __pyx_v_dst->data = (__pyx_v_dst->data + (__pyx_v_start * __pyx_v_stride)); + + /* "View.MemoryView":891 + * + * + * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< + * dst.data += start * stride + * else: + */ + goto __pyx_L23; + } + + /* "View.MemoryView":894 + * dst.data += start * stride + * else: + * dst.suboffsets[suboffset_dim[0]] += start * stride # <<<<<<<<<<<<<< + * + * if suboffset >= 0: + */ + /*else*/ { + __pyx_t_3 = (__pyx_v_suboffset_dim[0]); + (__pyx_v_dst->suboffsets[__pyx_t_3]) = ((__pyx_v_dst->suboffsets[__pyx_t_3]) + (__pyx_v_start * __pyx_v_stride)); + } + __pyx_L23:; + + /* "View.MemoryView":896 + * dst.suboffsets[suboffset_dim[0]] += start * stride + * + * if suboffset >= 0: # <<<<<<<<<<<<<< + * if not is_slice: + * if new_ndim == 0: + */ + __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":897 + * + * if suboffset >= 0: + * if not is_slice: # <<<<<<<<<<<<<< + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset + */ + __pyx_t_2 = ((!(__pyx_v_is_slice != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":898 + * if suboffset >= 0: + * if not is_slice: + * if new_ndim == 0: # <<<<<<<<<<<<<< + * dst.data = ( dst.data)[0] + suboffset + * else: + */ + __pyx_t_2 = ((__pyx_v_new_ndim == 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":899 + * if not is_slice: + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset # <<<<<<<<<<<<<< + * else: + * _err_dim(IndexError, "All dimensions preceding dimension %d " + */ + __pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset); + + /* "View.MemoryView":898 + * if suboffset >= 0: + * if not is_slice: + * if new_ndim == 0: # <<<<<<<<<<<<<< + * dst.data = ( dst.data)[0] + suboffset + * else: + */ + goto __pyx_L26; + } + + /* "View.MemoryView":901 + * dst.data = ( dst.data)[0] + suboffset + * else: + * _err_dim(IndexError, "All dimensions preceding dimension %d " # <<<<<<<<<<<<<< + * "must be indexed and not sliced", dim) + * else: + */ + /*else*/ { + + /* "View.MemoryView":902 + * else: + * _err_dim(IndexError, "All dimensions preceding dimension %d " + * "must be indexed and not sliced", dim) # <<<<<<<<<<<<<< + * else: + * suboffset_dim[0] = new_ndim + */ + __pyx_t_3 = __pyx_memoryview_err_dim(__pyx_builtin_IndexError, ((char *)"All dimensions preceding dimension %d must be indexed and not sliced"), __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 901, __pyx_L1_error) + } + __pyx_L26:; + + /* "View.MemoryView":897 + * + * if suboffset >= 0: + * if not is_slice: # <<<<<<<<<<<<<< + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset + */ + goto __pyx_L25; + } + + /* "View.MemoryView":904 + * "must be indexed and not sliced", dim) + * else: + * suboffset_dim[0] = new_ndim # <<<<<<<<<<<<<< + * + * return 0 + */ + /*else*/ { + (__pyx_v_suboffset_dim[0]) = __pyx_v_new_ndim; + } + __pyx_L25:; + + /* "View.MemoryView":896 + * dst.suboffsets[suboffset_dim[0]] += start * stride + * + * if suboffset >= 0: # <<<<<<<<<<<<<< + * if not is_slice: + * if new_ndim == 0: + */ + } + + /* "View.MemoryView":906 + * suboffset_dim[0] = new_ndim + * + * return 0 # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":809 + * + * @cname('__pyx_memoryview_slice_memviewslice') + * cdef int slice_memviewslice( # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.slice_memviewslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":912 + * + * @cname('__pyx_pybuffer_index') + * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 + */ + +static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, Py_ssize_t __pyx_v_index, Py_ssize_t __pyx_v_dim) { + Py_ssize_t __pyx_v_shape; + Py_ssize_t __pyx_v_stride; + Py_ssize_t __pyx_v_suboffset; + Py_ssize_t __pyx_v_itemsize; + char *__pyx_v_resultp; + char *__pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("pybuffer_index", 0); + + /* "View.MemoryView":914 + * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 # <<<<<<<<<<<<<< + * cdef Py_ssize_t itemsize = view.itemsize + * cdef char *resultp + */ + __pyx_v_suboffset = -1L; + + /* "View.MemoryView":915 + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 + * cdef Py_ssize_t itemsize = view.itemsize # <<<<<<<<<<<<<< + * cdef char *resultp + * + */ + __pyx_t_1 = __pyx_v_view->itemsize; + __pyx_v_itemsize = __pyx_t_1; + + /* "View.MemoryView":918 + * cdef char *resultp + * + * if view.ndim == 0: # <<<<<<<<<<<<<< + * shape = view.len / itemsize + * stride = itemsize + */ + __pyx_t_2 = ((__pyx_v_view->ndim == 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":919 + * + * if view.ndim == 0: + * shape = view.len / itemsize # <<<<<<<<<<<<<< + * stride = itemsize + * else: + */ + if (unlikely(__pyx_v_itemsize == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); + __PYX_ERR(1, 919, __pyx_L1_error) + } + else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(UNARY_NEG_WOULD_OVERFLOW(__pyx_v_view->len))) { + PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); + __PYX_ERR(1, 919, __pyx_L1_error) + } + __pyx_v_shape = __Pyx_div_Py_ssize_t(__pyx_v_view->len, __pyx_v_itemsize); + + /* "View.MemoryView":920 + * if view.ndim == 0: + * shape = view.len / itemsize + * stride = itemsize # <<<<<<<<<<<<<< + * else: + * shape = view.shape[dim] + */ + __pyx_v_stride = __pyx_v_itemsize; + + /* "View.MemoryView":918 + * cdef char *resultp + * + * if view.ndim == 0: # <<<<<<<<<<<<<< + * shape = view.len / itemsize + * stride = itemsize + */ + goto __pyx_L3; + } + + /* "View.MemoryView":922 + * stride = itemsize + * else: + * shape = view.shape[dim] # <<<<<<<<<<<<<< + * stride = view.strides[dim] + * if view.suboffsets != NULL: + */ + /*else*/ { + __pyx_v_shape = (__pyx_v_view->shape[__pyx_v_dim]); + + /* "View.MemoryView":923 + * else: + * shape = view.shape[dim] + * stride = view.strides[dim] # <<<<<<<<<<<<<< + * if view.suboffsets != NULL: + * suboffset = view.suboffsets[dim] + */ + __pyx_v_stride = (__pyx_v_view->strides[__pyx_v_dim]); + + /* "View.MemoryView":924 + * shape = view.shape[dim] + * stride = view.strides[dim] + * if view.suboffsets != NULL: # <<<<<<<<<<<<<< + * suboffset = view.suboffsets[dim] + * + */ + __pyx_t_2 = ((__pyx_v_view->suboffsets != NULL) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":925 + * stride = view.strides[dim] + * if view.suboffsets != NULL: + * suboffset = view.suboffsets[dim] # <<<<<<<<<<<<<< + * + * if index < 0: + */ + __pyx_v_suboffset = (__pyx_v_view->suboffsets[__pyx_v_dim]); + + /* "View.MemoryView":924 + * shape = view.shape[dim] + * stride = view.strides[dim] + * if view.suboffsets != NULL: # <<<<<<<<<<<<<< + * suboffset = view.suboffsets[dim] + * + */ + } + } + __pyx_L3:; + + /* "View.MemoryView":927 + * suboffset = view.suboffsets[dim] + * + * if index < 0: # <<<<<<<<<<<<<< + * index += view.shape[dim] + * if index < 0: + */ + __pyx_t_2 = ((__pyx_v_index < 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":928 + * + * if index < 0: + * index += view.shape[dim] # <<<<<<<<<<<<<< + * if index < 0: + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + */ + __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim])); + + /* "View.MemoryView":929 + * if index < 0: + * index += view.shape[dim] + * if index < 0: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + __pyx_t_2 = ((__pyx_v_index < 0) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":930 + * index += view.shape[dim] + * if index < 0: + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<< + * + * if index >= shape: + */ + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 930, __pyx_L1_error) + + /* "View.MemoryView":929 + * if index < 0: + * index += view.shape[dim] + * if index < 0: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + } + + /* "View.MemoryView":927 + * suboffset = view.suboffsets[dim] + * + * if index < 0: # <<<<<<<<<<<<<< + * index += view.shape[dim] + * if index < 0: + */ + } + + /* "View.MemoryView":932 + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + * if index >= shape: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + __pyx_t_2 = ((__pyx_v_index >= __pyx_v_shape) != 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":933 + * + * if index >= shape: + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) # <<<<<<<<<<<<<< + * + * resultp = bufp + index * stride + */ + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyString_Format(__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_CallOneArg(__pyx_builtin_IndexError, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_3, 0, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 933, __pyx_L1_error) + + /* "View.MemoryView":932 + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + * if index >= shape: # <<<<<<<<<<<<<< + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + */ + } + + /* "View.MemoryView":935 + * raise IndexError("Out of bounds on buffer access (axis %d)" % dim) + * + * resultp = bufp + index * stride # <<<<<<<<<<<<<< + * if suboffset >= 0: + * resultp = ( resultp)[0] + suboffset + */ + __pyx_v_resultp = (__pyx_v_bufp + (__pyx_v_index * __pyx_v_stride)); + + /* "View.MemoryView":936 + * + * resultp = bufp + index * stride + * if suboffset >= 0: # <<<<<<<<<<<<<< + * resultp = ( resultp)[0] + suboffset + * + */ + __pyx_t_2 = ((__pyx_v_suboffset >= 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":937 + * resultp = bufp + index * stride + * if suboffset >= 0: + * resultp = ( resultp)[0] + suboffset # <<<<<<<<<<<<<< + * + * return resultp + */ + __pyx_v_resultp = ((((char **)__pyx_v_resultp)[0]) + __pyx_v_suboffset); + + /* "View.MemoryView":936 + * + * resultp = bufp + index * stride + * if suboffset >= 0: # <<<<<<<<<<<<<< + * resultp = ( resultp)[0] + suboffset + * + */ + } + + /* "View.MemoryView":939 + * resultp = ( resultp)[0] + suboffset + * + * return resultp # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_resultp; + goto __pyx_L0; + + /* "View.MemoryView":912 + * + * @cname('__pyx_pybuffer_index') + * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, # <<<<<<<<<<<<<< + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView.pybuffer_index", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":945 + * + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< + * cdef int ndim = memslice.memview.view.ndim + * + */ + +static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { + int __pyx_v_ndim; + Py_ssize_t *__pyx_v_shape; + Py_ssize_t *__pyx_v_strides; + int __pyx_v_i; + int __pyx_v_j; + int __pyx_r; + int __pyx_t_1; + Py_ssize_t *__pyx_t_2; + long __pyx_t_3; + long __pyx_t_4; + Py_ssize_t __pyx_t_5; + Py_ssize_t __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":946 + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: + * cdef int ndim = memslice.memview.view.ndim # <<<<<<<<<<<<<< + * + * cdef Py_ssize_t *shape = memslice.shape + */ + __pyx_t_1 = __pyx_v_memslice->memview->view.ndim; + __pyx_v_ndim = __pyx_t_1; + + /* "View.MemoryView":948 + * cdef int ndim = memslice.memview.view.ndim + * + * cdef Py_ssize_t *shape = memslice.shape # <<<<<<<<<<<<<< + * cdef Py_ssize_t *strides = memslice.strides + * + */ + __pyx_t_2 = __pyx_v_memslice->shape; + __pyx_v_shape = __pyx_t_2; + + /* "View.MemoryView":949 + * + * cdef Py_ssize_t *shape = memslice.shape + * cdef Py_ssize_t *strides = memslice.strides # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = __pyx_v_memslice->strides; + __pyx_v_strides = __pyx_t_2; + + /* "View.MemoryView":953 + * + * cdef int i, j + * for i in range(ndim / 2): # <<<<<<<<<<<<<< + * j = ndim - 1 - i + * strides[i], strides[j] = strides[j], strides[i] + */ + __pyx_t_3 = __Pyx_div_long(__pyx_v_ndim, 2); + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_1 = 0; __pyx_t_1 < __pyx_t_4; __pyx_t_1+=1) { + __pyx_v_i = __pyx_t_1; + + /* "View.MemoryView":954 + * cdef int i, j + * for i in range(ndim / 2): + * j = ndim - 1 - i # <<<<<<<<<<<<<< + * strides[i], strides[j] = strides[j], strides[i] + * shape[i], shape[j] = shape[j], shape[i] + */ + __pyx_v_j = ((__pyx_v_ndim - 1) - __pyx_v_i); + + /* "View.MemoryView":955 + * for i in range(ndim / 2): + * j = ndim - 1 - i + * strides[i], strides[j] = strides[j], strides[i] # <<<<<<<<<<<<<< + * shape[i], shape[j] = shape[j], shape[i] + * + */ + __pyx_t_5 = (__pyx_v_strides[__pyx_v_j]); + __pyx_t_6 = (__pyx_v_strides[__pyx_v_i]); + (__pyx_v_strides[__pyx_v_i]) = __pyx_t_5; + (__pyx_v_strides[__pyx_v_j]) = __pyx_t_6; + + /* "View.MemoryView":956 + * j = ndim - 1 - i + * strides[i], strides[j] = strides[j], strides[i] + * shape[i], shape[j] = shape[j], shape[i] # <<<<<<<<<<<<<< + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: + */ + __pyx_t_6 = (__pyx_v_shape[__pyx_v_j]); + __pyx_t_5 = (__pyx_v_shape[__pyx_v_i]); + (__pyx_v_shape[__pyx_v_i]) = __pyx_t_6; + (__pyx_v_shape[__pyx_v_j]) = __pyx_t_5; + + /* "View.MemoryView":958 + * shape[i], shape[j] = shape[j], shape[i] + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + */ + __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 0) != 0); + if (!__pyx_t_8) { + } else { + __pyx_t_7 = __pyx_t_8; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_8 = (((__pyx_v_memslice->suboffsets[__pyx_v_j]) >= 0) != 0); + __pyx_t_7 = __pyx_t_8; + __pyx_L6_bool_binop_done:; + if (__pyx_t_7) { + + /* "View.MemoryView":959 + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") # <<<<<<<<<<<<<< + * + * return 1 + */ + __pyx_t_9 = __pyx_memoryview_err(__pyx_builtin_ValueError, ((char *)"Cannot transpose memoryview with indirect dimensions")); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 959, __pyx_L1_error) + + /* "View.MemoryView":958 + * shape[i], shape[j] = shape[j], shape[i] + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + */ + } + } + + /* "View.MemoryView":961 + * _err(ValueError, "Cannot transpose memoryview with indirect dimensions") + * + * return 1 # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = 1; + goto __pyx_L0; + + /* "View.MemoryView":945 + * + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) nogil except 0: # <<<<<<<<<<<<<< + * cdef int ndim = memslice.memview.view.ndim + * + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.transpose_memslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = 0; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":978 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + */ + +/* Python wrapper */ +static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__", 0); + + /* "View.MemoryView":979 + * + * def __dealloc__(self): + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<< + * + * cdef convert_item_to_object(self, char *itemp): + */ + __PYX_XDEC_MEMVIEW((&__pyx_v_self->from_slice), 1); + + /* "View.MemoryView":978 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":981 + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * if self.to_object_func != NULL: + * return self.to_object_func(itemp) + */ + +static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("convert_item_to_object", 0); + + /* "View.MemoryView":982 + * + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: # <<<<<<<<<<<<<< + * return self.to_object_func(itemp) + * else: + */ + __pyx_t_1 = ((__pyx_v_self->to_object_func != NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":983 + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: + * return self.to_object_func(itemp) # <<<<<<<<<<<<<< + * else: + * return memoryview.convert_item_to_object(self, itemp) + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_v_self->to_object_func(__pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 983, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":982 + * + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: # <<<<<<<<<<<<<< + * return self.to_object_func(itemp) + * else: + */ + } + + /* "View.MemoryView":985 + * return self.to_object_func(itemp) + * else: + * return memoryview.convert_item_to_object(self, itemp) # <<<<<<<<<<<<<< + * + * cdef assign_item_from_object(self, char *itemp, object value): + */ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_memoryview_convert_item_to_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 985, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":981 + * __PYX_XDEC_MEMVIEW(&self.from_slice, 1) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * if self.to_object_func != NULL: + * return self.to_object_func(itemp) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":987 + * return memoryview.convert_item_to_object(self, itemp) + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * if self.to_dtype_func != NULL: + * self.to_dtype_func(itemp, value) + */ + +static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("assign_item_from_object", 0); + + /* "View.MemoryView":988 + * + * cdef assign_item_from_object(self, char *itemp, object value): + * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< + * self.to_dtype_func(itemp, value) + * else: + */ + __pyx_t_1 = ((__pyx_v_self->to_dtype_func != NULL) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":989 + * cdef assign_item_from_object(self, char *itemp, object value): + * if self.to_dtype_func != NULL: + * self.to_dtype_func(itemp, value) # <<<<<<<<<<<<<< + * else: + * memoryview.assign_item_from_object(self, itemp, value) + */ + __pyx_t_2 = __pyx_v_self->to_dtype_func(__pyx_v_itemp, __pyx_v_value); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 989, __pyx_L1_error) + + /* "View.MemoryView":988 + * + * cdef assign_item_from_object(self, char *itemp, object value): + * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< + * self.to_dtype_func(itemp, value) + * else: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":991 + * self.to_dtype_func(itemp, value) + * else: + * memoryview.assign_item_from_object(self, itemp, value) # <<<<<<<<<<<<<< + * + * @property + */ + /*else*/ { + __pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 991, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L3:; + + /* "View.MemoryView":987 + * return memoryview.convert_item_to_object(self, itemp) + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * if self.to_dtype_func != NULL: + * self.to_dtype_func(itemp, value) + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":994 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.from_object + * + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(PyObject *__pyx_v_self) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_r = __pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_16_memoryviewslice_4base___get__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":995 + * @property + * def base(self): + * return self.from_object # <<<<<<<<<<<<<< + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->from_object); + __pyx_r = __pyx_v_self->from_object; + goto __pyx_L0; + + /* "View.MemoryView":994 + * + * @property + * def base(self): # <<<<<<<<<<<<<< + * return self.from_object + * + */ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): + */ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, CYTHON_UNUSED PyObject *unused) { + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + __pyx_r = __pyx_pf___pyx_memoryviewslice___reduce_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + __pyx_t_1 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__17, 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__18, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError("no default __reduce__ due to non-trivial __cinit__") + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1001 + * + * @cname('__pyx_memoryview_fromslice') + * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< + * int ndim, + * object (*to_object_func)(char *), + */ + +static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewslice, int __pyx_v_ndim, PyObject *(*__pyx_v_to_object_func)(char *), int (*__pyx_v_to_dtype_func)(char *, PyObject *), int __pyx_v_dtype_is_object) { + struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; + Py_ssize_t __pyx_v_suboffset; + PyObject *__pyx_v_length = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_TypeInfo *__pyx_t_4; + Py_buffer __pyx_t_5; + Py_ssize_t *__pyx_t_6; + Py_ssize_t *__pyx_t_7; + Py_ssize_t *__pyx_t_8; + Py_ssize_t __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_fromslice", 0); + + /* "View.MemoryView":1009 + * cdef _memoryviewslice result + * + * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< + * return None + * + */ + __pyx_t_1 = ((((PyObject *)__pyx_v_memviewslice.memview) == Py_None) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1010 + * + * if memviewslice.memview == Py_None: + * return None # <<<<<<<<<<<<<< + * + * + */ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "View.MemoryView":1009 + * cdef _memoryviewslice result + * + * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< + * return None + * + */ + } + + /* "View.MemoryView":1015 + * + * + * result = _memoryviewslice(None, 0, dtype_is_object) # <<<<<<<<<<<<<< + * + * result.from_slice = memviewslice + */ + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1015, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1015, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None); + __Pyx_INCREF(__pyx_int_0); + __Pyx_GIVEREF(__pyx_int_0); + PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_int_0); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_Call(((PyObject *)__pyx_memoryviewslice_type), __pyx_t_3, NULL); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1015, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":1017 + * result = _memoryviewslice(None, 0, dtype_is_object) + * + * result.from_slice = memviewslice # <<<<<<<<<<<<<< + * __PYX_INC_MEMVIEW(&memviewslice, 1) + * + */ + __pyx_v_result->from_slice = __pyx_v_memviewslice; + + /* "View.MemoryView":1018 + * + * result.from_slice = memviewslice + * __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<< + * + * result.from_object = ( memviewslice.memview).base + */ + __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1); + + /* "View.MemoryView":1020 + * __PYX_INC_MEMVIEW(&memviewslice, 1) + * + * result.from_object = ( memviewslice.memview).base # <<<<<<<<<<<<<< + * result.typeinfo = memviewslice.memview.typeinfo + * + */ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_memviewslice.memview), __pyx_n_s_base); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1020, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_result->from_object); + __Pyx_DECREF(__pyx_v_result->from_object); + __pyx_v_result->from_object = __pyx_t_2; + __pyx_t_2 = 0; + + /* "View.MemoryView":1021 + * + * result.from_object = ( memviewslice.memview).base + * result.typeinfo = memviewslice.memview.typeinfo # <<<<<<<<<<<<<< + * + * result.view = memviewslice.memview.view + */ + __pyx_t_4 = __pyx_v_memviewslice.memview->typeinfo; + __pyx_v_result->__pyx_base.typeinfo = __pyx_t_4; + + /* "View.MemoryView":1023 + * result.typeinfo = memviewslice.memview.typeinfo + * + * result.view = memviewslice.memview.view # <<<<<<<<<<<<<< + * result.view.buf = memviewslice.data + * result.view.ndim = ndim + */ + __pyx_t_5 = __pyx_v_memviewslice.memview->view; + __pyx_v_result->__pyx_base.view = __pyx_t_5; + + /* "View.MemoryView":1024 + * + * result.view = memviewslice.memview.view + * result.view.buf = memviewslice.data # <<<<<<<<<<<<<< + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None + */ + __pyx_v_result->__pyx_base.view.buf = ((void *)__pyx_v_memviewslice.data); + + /* "View.MemoryView":1025 + * result.view = memviewslice.memview.view + * result.view.buf = memviewslice.data + * result.view.ndim = ndim # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &result.view).obj = Py_None + * Py_INCREF(Py_None) + */ + __pyx_v_result->__pyx_base.view.ndim = __pyx_v_ndim; + + /* "View.MemoryView":1026 + * result.view.buf = memviewslice.data + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * + */ + ((Py_buffer *)(&__pyx_v_result->__pyx_base.view))->obj = Py_None; + + /* "View.MemoryView":1027 + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: + */ + Py_INCREF(Py_None); + + /* "View.MemoryView":1029 + * Py_INCREF(Py_None) + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< + * result.flags = PyBUF_RECORDS + * else: + */ + __pyx_t_1 = ((((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->flags & PyBUF_WRITABLE) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1030 + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: + * result.flags = PyBUF_RECORDS # <<<<<<<<<<<<<< + * else: + * result.flags = PyBUF_RECORDS_RO + */ + __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS; + + /* "View.MemoryView":1029 + * Py_INCREF(Py_None) + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< + * result.flags = PyBUF_RECORDS + * else: + */ + goto __pyx_L4; + } + + /* "View.MemoryView":1032 + * result.flags = PyBUF_RECORDS + * else: + * result.flags = PyBUF_RECORDS_RO # <<<<<<<<<<<<<< + * + * result.view.shape = result.from_slice.shape + */ + /*else*/ { + __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS_RO; + } + __pyx_L4:; + + /* "View.MemoryView":1034 + * result.flags = PyBUF_RECORDS_RO + * + * result.view.shape = result.from_slice.shape # <<<<<<<<<<<<<< + * result.view.strides = result.from_slice.strides + * + */ + __pyx_v_result->__pyx_base.view.shape = ((Py_ssize_t *)__pyx_v_result->from_slice.shape); + + /* "View.MemoryView":1035 + * + * result.view.shape = result.from_slice.shape + * result.view.strides = result.from_slice.strides # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_result->__pyx_base.view.strides = ((Py_ssize_t *)__pyx_v_result->from_slice.strides); + + /* "View.MemoryView":1038 + * + * + * result.view.suboffsets = NULL # <<<<<<<<<<<<<< + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: + */ + __pyx_v_result->__pyx_base.view.suboffsets = NULL; + + /* "View.MemoryView":1039 + * + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: # <<<<<<<<<<<<<< + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets + */ + __pyx_t_7 = (__pyx_v_result->from_slice.suboffsets + __pyx_v_ndim); + for (__pyx_t_8 = __pyx_v_result->from_slice.suboffsets; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { + __pyx_t_6 = __pyx_t_8; + __pyx_v_suboffset = (__pyx_t_6[0]); + + /* "View.MemoryView":1040 + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * result.view.suboffsets = result.from_slice.suboffsets + * break + */ + __pyx_t_1 = ((__pyx_v_suboffset >= 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1041 + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets # <<<<<<<<<<<<<< + * break + * + */ + __pyx_v_result->__pyx_base.view.suboffsets = ((Py_ssize_t *)__pyx_v_result->from_slice.suboffsets); + + /* "View.MemoryView":1042 + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets + * break # <<<<<<<<<<<<<< + * + * result.view.len = result.view.itemsize + */ + goto __pyx_L6_break; + + /* "View.MemoryView":1040 + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * result.view.suboffsets = result.from_slice.suboffsets + * break + */ + } + } + __pyx_L6_break:; + + /* "View.MemoryView":1044 + * break + * + * result.view.len = result.view.itemsize # <<<<<<<<<<<<<< + * for length in result.view.shape[:ndim]: + * result.view.len *= length + */ + __pyx_t_9 = __pyx_v_result->__pyx_base.view.itemsize; + __pyx_v_result->__pyx_base.view.len = __pyx_t_9; + + /* "View.MemoryView":1045 + * + * result.view.len = result.view.itemsize + * for length in result.view.shape[:ndim]: # <<<<<<<<<<<<<< + * result.view.len *= length + * + */ + __pyx_t_7 = (__pyx_v_result->__pyx_base.view.shape + __pyx_v_ndim); + for (__pyx_t_8 = __pyx_v_result->__pyx_base.view.shape; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { + __pyx_t_6 = __pyx_t_8; + __pyx_t_2 = PyInt_FromSsize_t((__pyx_t_6[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":1046 + * result.view.len = result.view.itemsize + * for length in result.view.shape[:ndim]: + * result.view.len *= length # <<<<<<<<<<<<<< + * + * result.to_object_func = to_object_func + */ + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_result->__pyx_base.view.len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1046, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_t_2, __pyx_v_length); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1046, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 1046, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result->__pyx_base.view.len = __pyx_t_9; + } + + /* "View.MemoryView":1048 + * result.view.len *= length + * + * result.to_object_func = to_object_func # <<<<<<<<<<<<<< + * result.to_dtype_func = to_dtype_func + * + */ + __pyx_v_result->to_object_func = __pyx_v_to_object_func; + + /* "View.MemoryView":1049 + * + * result.to_object_func = to_object_func + * result.to_dtype_func = to_dtype_func # <<<<<<<<<<<<<< + * + * return result + */ + __pyx_v_result->to_dtype_func = __pyx_v_to_dtype_func; + + /* "View.MemoryView":1051 + * result.to_dtype_func = to_dtype_func + * + * return result # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_result)); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "View.MemoryView":1001 + * + * @cname('__pyx_memoryview_fromslice') + * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, # <<<<<<<<<<<<<< + * int ndim, + * object (*to_object_func)(char *), + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview_fromslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XDECREF(__pyx_v_length); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1054 + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') + * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + */ + +static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_mslice) { + struct __pyx_memoryviewslice_obj *__pyx_v_obj = 0; + __Pyx_memviewslice *__pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_slice_from_memview", 0); + + /* "View.MemoryView":1057 + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * obj = memview + * return &obj.from_slice + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1058 + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): + * obj = memview # <<<<<<<<<<<<<< + * return &obj.from_slice + * else: + */ + if (!(likely(((((PyObject *)__pyx_v_memview)) == Py_None) || likely(__Pyx_TypeTest(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type))))) __PYX_ERR(1, 1058, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_v_memview); + __Pyx_INCREF(__pyx_t_3); + __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":1059 + * if isinstance(memview, _memoryviewslice): + * obj = memview + * return &obj.from_slice # <<<<<<<<<<<<<< + * else: + * slice_copy(memview, mslice) + */ + __pyx_r = (&__pyx_v_obj->from_slice); + goto __pyx_L0; + + /* "View.MemoryView":1057 + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * obj = memview + * return &obj.from_slice + */ + } + + /* "View.MemoryView":1061 + * return &obj.from_slice + * else: + * slice_copy(memview, mslice) # <<<<<<<<<<<<<< + * return mslice + * + */ + /*else*/ { + __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice); + + /* "View.MemoryView":1062 + * else: + * slice_copy(memview, mslice) + * return mslice # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_slice_copy') + */ + __pyx_r = __pyx_v_mslice; + goto __pyx_L0; + } + + /* "View.MemoryView":1054 + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') + * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.get_slice_from_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_obj); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1065 + * + * @cname('__pyx_memoryview_slice_copy') + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< + * cdef int dim + * cdef (Py_ssize_t*) shape, strides, suboffsets + */ + +static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_dst) { + int __pyx_v_dim; + Py_ssize_t *__pyx_v_shape; + Py_ssize_t *__pyx_v_strides; + Py_ssize_t *__pyx_v_suboffsets; + __Pyx_RefNannyDeclarations + Py_ssize_t *__pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + Py_ssize_t __pyx_t_5; + __Pyx_RefNannySetupContext("slice_copy", 0); + + /* "View.MemoryView":1069 + * cdef (Py_ssize_t*) shape, strides, suboffsets + * + * shape = memview.view.shape # <<<<<<<<<<<<<< + * strides = memview.view.strides + * suboffsets = memview.view.suboffsets + */ + __pyx_t_1 = __pyx_v_memview->view.shape; + __pyx_v_shape = __pyx_t_1; + + /* "View.MemoryView":1070 + * + * shape = memview.view.shape + * strides = memview.view.strides # <<<<<<<<<<<<<< + * suboffsets = memview.view.suboffsets + * + */ + __pyx_t_1 = __pyx_v_memview->view.strides; + __pyx_v_strides = __pyx_t_1; + + /* "View.MemoryView":1071 + * shape = memview.view.shape + * strides = memview.view.strides + * suboffsets = memview.view.suboffsets # <<<<<<<<<<<<<< + * + * dst.memview = <__pyx_memoryview *> memview + */ + __pyx_t_1 = __pyx_v_memview->view.suboffsets; + __pyx_v_suboffsets = __pyx_t_1; + + /* "View.MemoryView":1073 + * suboffsets = memview.view.suboffsets + * + * dst.memview = <__pyx_memoryview *> memview # <<<<<<<<<<<<<< + * dst.data = memview.view.buf + * + */ + __pyx_v_dst->memview = ((struct __pyx_memoryview_obj *)__pyx_v_memview); + + /* "View.MemoryView":1074 + * + * dst.memview = <__pyx_memoryview *> memview + * dst.data = memview.view.buf # <<<<<<<<<<<<<< + * + * for dim in range(memview.view.ndim): + */ + __pyx_v_dst->data = ((char *)__pyx_v_memview->view.buf); + + /* "View.MemoryView":1076 + * dst.data = memview.view.buf + * + * for dim in range(memview.view.ndim): # <<<<<<<<<<<<<< + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] + */ + __pyx_t_2 = __pyx_v_memview->view.ndim; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_dim = __pyx_t_4; + + /* "View.MemoryView":1077 + * + * for dim in range(memview.view.ndim): + * dst.shape[dim] = shape[dim] # <<<<<<<<<<<<<< + * dst.strides[dim] = strides[dim] + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 + */ + (__pyx_v_dst->shape[__pyx_v_dim]) = (__pyx_v_shape[__pyx_v_dim]); + + /* "View.MemoryView":1078 + * for dim in range(memview.view.ndim): + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] # <<<<<<<<<<<<<< + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 + * + */ + (__pyx_v_dst->strides[__pyx_v_dim]) = (__pyx_v_strides[__pyx_v_dim]); + + /* "View.MemoryView":1079 + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_object') + */ + if ((__pyx_v_suboffsets != 0)) { + __pyx_t_5 = (__pyx_v_suboffsets[__pyx_v_dim]); + } else { + __pyx_t_5 = -1L; + } + (__pyx_v_dst->suboffsets[__pyx_v_dim]) = __pyx_t_5; + } + + /* "View.MemoryView":1065 + * + * @cname('__pyx_memoryview_slice_copy') + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst): # <<<<<<<<<<<<<< + * cdef int dim + * cdef (Py_ssize_t*) shape, strides, suboffsets + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":1082 + * + * @cname('__pyx_memoryview_copy_object') + * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< + * "Create a new memoryview object" + * cdef __Pyx_memviewslice memviewslice + */ + +static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx_v_memview) { + __Pyx_memviewslice __pyx_v_memviewslice; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_copy", 0); + + /* "View.MemoryView":1085 + * "Create a new memoryview object" + * cdef __Pyx_memviewslice memviewslice + * slice_copy(memview, &memviewslice) # <<<<<<<<<<<<<< + * return memoryview_copy_from_slice(memview, &memviewslice) + * + */ + __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_memviewslice)); + + /* "View.MemoryView":1086 + * cdef __Pyx_memviewslice memviewslice + * slice_copy(memview, &memviewslice) + * return memoryview_copy_from_slice(memview, &memviewslice) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_object_from_slice') + */ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_memoryview_copy_object_from_slice(__pyx_v_memview, (&__pyx_v_memviewslice)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1086, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":1082 + * + * @cname('__pyx_memoryview_copy_object') + * cdef memoryview_copy(memoryview memview): # <<<<<<<<<<<<<< + * "Create a new memoryview object" + * cdef __Pyx_memviewslice memviewslice + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview_copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1089 + * + * @cname('__pyx_memoryview_copy_object_from_slice') + * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< + * """ + * Create a new memoryview object from a given memoryview object and slice. + */ + +static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_memviewslice) { + PyObject *(*__pyx_v_to_object_func)(char *); + int (*__pyx_v_to_dtype_func)(char *, PyObject *); + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *(*__pyx_t_3)(char *); + int (*__pyx_t_4)(char *, PyObject *); + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 0); + + /* "View.MemoryView":1096 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + */ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_memoryviewslice_type); + __pyx_t_2 = (__pyx_t_1 != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1097 + * + * if isinstance(memview, _memoryviewslice): + * to_object_func = (<_memoryviewslice> memview).to_object_func # <<<<<<<<<<<<<< + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + * else: + */ + __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func; + __pyx_v_to_object_func = __pyx_t_3; + + /* "View.MemoryView":1098 + * if isinstance(memview, _memoryviewslice): + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func # <<<<<<<<<<<<<< + * else: + * to_object_func = NULL + */ + __pyx_t_4 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func; + __pyx_v_to_dtype_func = __pyx_t_4; + + /* "View.MemoryView":1096 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1100 + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + * else: + * to_object_func = NULL # <<<<<<<<<<<<<< + * to_dtype_func = NULL + * + */ + /*else*/ { + __pyx_v_to_object_func = NULL; + + /* "View.MemoryView":1101 + * else: + * to_object_func = NULL + * to_dtype_func = NULL # <<<<<<<<<<<<<< + * + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, + */ + __pyx_v_to_dtype_func = NULL; + } + __pyx_L3:; + + /* "View.MemoryView":1103 + * to_dtype_func = NULL + * + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, # <<<<<<<<<<<<<< + * to_object_func, to_dtype_func, + * memview.dtype_is_object) + */ + __Pyx_XDECREF(__pyx_r); + + /* "View.MemoryView":1105 + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, + * to_object_func, to_dtype_func, + * memview.dtype_is_object) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_5 = __pyx_memoryview_fromslice((__pyx_v_memviewslice[0]), __pyx_v_memview->view.ndim, __pyx_v_to_object_func, __pyx_v_to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "View.MemoryView":1089 + * + * @cname('__pyx_memoryview_copy_object_from_slice') + * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): # <<<<<<<<<<<<<< + * """ + * Create a new memoryview object from a given memoryview object and slice. + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview_copy_from_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1111 + * + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< + * if arg < 0: + * return -arg + */ + +static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { + Py_ssize_t __pyx_r; + int __pyx_t_1; + + /* "View.MemoryView":1112 + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: # <<<<<<<<<<<<<< + * return -arg + * else: + */ + __pyx_t_1 = ((__pyx_v_arg < 0) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1113 + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: + * return -arg # <<<<<<<<<<<<<< + * else: + * return arg + */ + __pyx_r = (-__pyx_v_arg); + goto __pyx_L0; + + /* "View.MemoryView":1112 + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: + * if arg < 0: # <<<<<<<<<<<<<< + * return -arg + * else: + */ + } + + /* "View.MemoryView":1115 + * return -arg + * else: + * return arg # <<<<<<<<<<<<<< + * + * @cname('__pyx_get_best_slice_order') + */ + /*else*/ { + __pyx_r = __pyx_v_arg; + goto __pyx_L0; + } + + /* "View.MemoryView":1111 + * + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) nogil: # <<<<<<<<<<<<<< + * if arg < 0: + * return -arg + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1118 + * + * @cname('__pyx_get_best_slice_order') + * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< + * """ + * Figure out the best memory access order for a given slice. + */ + +static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim) { + int __pyx_v_i; + Py_ssize_t __pyx_v_c_stride; + Py_ssize_t __pyx_v_f_stride; + char __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + + /* "View.MemoryView":1123 + * """ + * cdef int i + * cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<< + * cdef Py_ssize_t f_stride = 0 + * + */ + __pyx_v_c_stride = 0; + + /* "View.MemoryView":1124 + * cdef int i + * cdef Py_ssize_t c_stride = 0 + * cdef Py_ssize_t f_stride = 0 # <<<<<<<<<<<<<< + * + * for i in range(ndim - 1, -1, -1): + */ + __pyx_v_f_stride = 0; + + /* "View.MemoryView":1126 + * cdef Py_ssize_t f_stride = 0 + * + * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] + */ + for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { + __pyx_v_i = __pyx_t_1; + + /* "View.MemoryView":1127 + * + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * c_stride = mslice.strides[i] + * break + */ + __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1128 + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] # <<<<<<<<<<<<<< + * break + * + */ + __pyx_v_c_stride = (__pyx_v_mslice->strides[__pyx_v_i]); + + /* "View.MemoryView":1129 + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] + * break # <<<<<<<<<<<<<< + * + * for i in range(ndim): + */ + goto __pyx_L4_break; + + /* "View.MemoryView":1127 + * + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * c_stride = mslice.strides[i] + * break + */ + } + } + __pyx_L4_break:; + + /* "View.MemoryView":1131 + * break + * + * for i in range(ndim): # <<<<<<<<<<<<<< + * if mslice.shape[i] > 1: + * f_stride = mslice.strides[i] + */ + __pyx_t_1 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_1; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1132 + * + * for i in range(ndim): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * f_stride = mslice.strides[i] + * break + */ + __pyx_t_2 = (((__pyx_v_mslice->shape[__pyx_v_i]) > 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1133 + * for i in range(ndim): + * if mslice.shape[i] > 1: + * f_stride = mslice.strides[i] # <<<<<<<<<<<<<< + * break + * + */ + __pyx_v_f_stride = (__pyx_v_mslice->strides[__pyx_v_i]); + + /* "View.MemoryView":1134 + * if mslice.shape[i] > 1: + * f_stride = mslice.strides[i] + * break # <<<<<<<<<<<<<< + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): + */ + goto __pyx_L7_break; + + /* "View.MemoryView":1132 + * + * for i in range(ndim): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * f_stride = mslice.strides[i] + * break + */ + } + } + __pyx_L7_break:; + + /* "View.MemoryView":1136 + * break + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< + * return 'C' + * else: + */ + __pyx_t_2 = ((abs_py_ssize_t(__pyx_v_c_stride) <= abs_py_ssize_t(__pyx_v_f_stride)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1137 + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): + * return 'C' # <<<<<<<<<<<<<< + * else: + * return 'F' + */ + __pyx_r = 'C'; + goto __pyx_L0; + + /* "View.MemoryView":1136 + * break + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< + * return 'C' + * else: + */ + } + + /* "View.MemoryView":1139 + * return 'C' + * else: + * return 'F' # <<<<<<<<<<<<<< + * + * @cython.cdivision(True) + */ + /*else*/ { + __pyx_r = 'F'; + goto __pyx_L0; + } + + /* "View.MemoryView":1118 + * + * @cname('__pyx_get_best_slice_order') + * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) nogil: # <<<<<<<<<<<<<< + * """ + * Figure out the best memory access order for a given slice. + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1142 + * + * @cython.cdivision(True) + * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< + * char *dst_data, Py_ssize_t *dst_strides, + * Py_ssize_t *src_shape, Py_ssize_t *dst_shape, + */ + +static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v_src_strides, char *__pyx_v_dst_data, Py_ssize_t *__pyx_v_dst_strides, Py_ssize_t *__pyx_v_src_shape, Py_ssize_t *__pyx_v_dst_shape, int __pyx_v_ndim, size_t __pyx_v_itemsize) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + CYTHON_UNUSED Py_ssize_t __pyx_v_src_extent; + Py_ssize_t __pyx_v_dst_extent; + Py_ssize_t __pyx_v_src_stride; + Py_ssize_t __pyx_v_dst_stride; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + Py_ssize_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + Py_ssize_t __pyx_t_6; + + /* "View.MemoryView":1149 + * + * cdef Py_ssize_t i + * cdef Py_ssize_t src_extent = src_shape[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t dst_extent = dst_shape[0] + * cdef Py_ssize_t src_stride = src_strides[0] + */ + __pyx_v_src_extent = (__pyx_v_src_shape[0]); + + /* "View.MemoryView":1150 + * cdef Py_ssize_t i + * cdef Py_ssize_t src_extent = src_shape[0] + * cdef Py_ssize_t dst_extent = dst_shape[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t src_stride = src_strides[0] + * cdef Py_ssize_t dst_stride = dst_strides[0] + */ + __pyx_v_dst_extent = (__pyx_v_dst_shape[0]); + + /* "View.MemoryView":1151 + * cdef Py_ssize_t src_extent = src_shape[0] + * cdef Py_ssize_t dst_extent = dst_shape[0] + * cdef Py_ssize_t src_stride = src_strides[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t dst_stride = dst_strides[0] + * + */ + __pyx_v_src_stride = (__pyx_v_src_strides[0]); + + /* "View.MemoryView":1152 + * cdef Py_ssize_t dst_extent = dst_shape[0] + * cdef Py_ssize_t src_stride = src_strides[0] + * cdef Py_ssize_t dst_stride = dst_strides[0] # <<<<<<<<<<<<<< + * + * if ndim == 1: + */ + __pyx_v_dst_stride = (__pyx_v_dst_strides[0]); + + /* "View.MemoryView":1154 + * cdef Py_ssize_t dst_stride = dst_strides[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): + */ + __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1155 + * + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) + */ + __pyx_t_2 = ((__pyx_v_src_stride > 0) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L5_bool_binop_done; + } + __pyx_t_2 = ((__pyx_v_dst_stride > 0) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L5_bool_binop_done; + } + + /* "View.MemoryView":1156 + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): # <<<<<<<<<<<<<< + * memcpy(dst_data, src_data, itemsize * dst_extent) + * else: + */ + __pyx_t_2 = (((size_t)__pyx_v_src_stride) == __pyx_v_itemsize); + if (__pyx_t_2) { + __pyx_t_2 = (__pyx_v_itemsize == ((size_t)__pyx_v_dst_stride)); + } + __pyx_t_3 = (__pyx_t_2 != 0); + __pyx_t_1 = __pyx_t_3; + __pyx_L5_bool_binop_done:; + + /* "View.MemoryView":1155 + * + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) + */ + if (__pyx_t_1) { + + /* "View.MemoryView":1157 + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) # <<<<<<<<<<<<<< + * else: + * for i in range(dst_extent): + */ + (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, (__pyx_v_itemsize * __pyx_v_dst_extent))); + + /* "View.MemoryView":1155 + * + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) + */ + goto __pyx_L4; + } + + /* "View.MemoryView":1159 + * memcpy(dst_data, src_data, itemsize * dst_extent) + * else: + * for i in range(dst_extent): # <<<<<<<<<<<<<< + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride + */ + /*else*/ { + __pyx_t_4 = __pyx_v_dst_extent; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1160 + * else: + * for i in range(dst_extent): + * memcpy(dst_data, src_data, itemsize) # <<<<<<<<<<<<<< + * src_data += src_stride + * dst_data += dst_stride + */ + (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, __pyx_v_itemsize)); + + /* "View.MemoryView":1161 + * for i in range(dst_extent): + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride # <<<<<<<<<<<<<< + * dst_data += dst_stride + * else: + */ + __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); + + /* "View.MemoryView":1162 + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride + * dst_data += dst_stride # <<<<<<<<<<<<<< + * else: + * for i in range(dst_extent): + */ + __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); + } + } + __pyx_L4:; + + /* "View.MemoryView":1154 + * cdef Py_ssize_t dst_stride = dst_strides[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1164 + * dst_data += dst_stride + * else: + * for i in range(dst_extent): # <<<<<<<<<<<<<< + * _copy_strided_to_strided(src_data, src_strides + 1, + * dst_data, dst_strides + 1, + */ + /*else*/ { + __pyx_t_4 = __pyx_v_dst_extent; + __pyx_t_5 = __pyx_t_4; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1165 + * else: + * for i in range(dst_extent): + * _copy_strided_to_strided(src_data, src_strides + 1, # <<<<<<<<<<<<<< + * dst_data, dst_strides + 1, + * src_shape + 1, dst_shape + 1, + */ + _copy_strided_to_strided(__pyx_v_src_data, (__pyx_v_src_strides + 1), __pyx_v_dst_data, (__pyx_v_dst_strides + 1), (__pyx_v_src_shape + 1), (__pyx_v_dst_shape + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize); + + /* "View.MemoryView":1169 + * src_shape + 1, dst_shape + 1, + * ndim - 1, itemsize) + * src_data += src_stride # <<<<<<<<<<<<<< + * dst_data += dst_stride + * + */ + __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); + + /* "View.MemoryView":1170 + * ndim - 1, itemsize) + * src_data += src_stride + * dst_data += dst_stride # <<<<<<<<<<<<<< + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, + */ + __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); + } + } + __pyx_L3:; + + /* "View.MemoryView":1142 + * + * @cython.cdivision(True) + * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, # <<<<<<<<<<<<<< + * char *dst_data, Py_ssize_t *dst_strides, + * Py_ssize_t *src_shape, Py_ssize_t *dst_shape, + */ + + /* function exit code */ +} + +/* "View.MemoryView":1172 + * dst_data += dst_stride + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) nogil: + */ + +static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize) { + + /* "View.MemoryView":1175 + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) nogil: + * _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides, # <<<<<<<<<<<<<< + * src.shape, dst.shape, ndim, itemsize) + * + */ + _copy_strided_to_strided(__pyx_v_src->data, __pyx_v_src->strides, __pyx_v_dst->data, __pyx_v_dst->strides, __pyx_v_src->shape, __pyx_v_dst->shape, __pyx_v_ndim, __pyx_v_itemsize); + + /* "View.MemoryView":1172 + * dst_data += dst_stride + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1179 + * + * @cname('__pyx_memoryview_slice_get_size') + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< + * "Return the size of the memory occupied by the slice in number of bytes" + * cdef Py_ssize_t shape, size = src.memview.view.itemsize + */ + +static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_src, int __pyx_v_ndim) { + Py_ssize_t __pyx_v_shape; + Py_ssize_t __pyx_v_size; + Py_ssize_t __pyx_r; + Py_ssize_t __pyx_t_1; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + + /* "View.MemoryView":1181 + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: + * "Return the size of the memory occupied by the slice in number of bytes" + * cdef Py_ssize_t shape, size = src.memview.view.itemsize # <<<<<<<<<<<<<< + * + * for shape in src.shape[:ndim]: + */ + __pyx_t_1 = __pyx_v_src->memview->view.itemsize; + __pyx_v_size = __pyx_t_1; + + /* "View.MemoryView":1183 + * cdef Py_ssize_t shape, size = src.memview.view.itemsize + * + * for shape in src.shape[:ndim]: # <<<<<<<<<<<<<< + * size *= shape + * + */ + __pyx_t_3 = (__pyx_v_src->shape + __pyx_v_ndim); + for (__pyx_t_4 = __pyx_v_src->shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { + __pyx_t_2 = __pyx_t_4; + __pyx_v_shape = (__pyx_t_2[0]); + + /* "View.MemoryView":1184 + * + * for shape in src.shape[:ndim]: + * size *= shape # <<<<<<<<<<<<<< + * + * return size + */ + __pyx_v_size = (__pyx_v_size * __pyx_v_shape); + } + + /* "View.MemoryView":1186 + * size *= shape + * + * return size # <<<<<<<<<<<<<< + * + * @cname('__pyx_fill_contig_strides_array') + */ + __pyx_r = __pyx_v_size; + goto __pyx_L0; + + /* "View.MemoryView":1179 + * + * @cname('__pyx_memoryview_slice_get_size') + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) nogil: # <<<<<<<<<<<<<< + * "Return the size of the memory occupied by the slice in number of bytes" + * cdef Py_ssize_t shape, size = src.memview.view.itemsize + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1189 + * + * @cname('__pyx_fill_contig_strides_array') + * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< + * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, + * int ndim, char order) nogil: + */ + +static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, Py_ssize_t __pyx_v_stride, int __pyx_v_ndim, char __pyx_v_order) { + int __pyx_v_idx; + Py_ssize_t __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + + /* "View.MemoryView":1198 + * cdef int idx + * + * if order == 'F': # <<<<<<<<<<<<<< + * for idx in range(ndim): + * strides[idx] = stride + */ + __pyx_t_1 = ((__pyx_v_order == 'F') != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1199 + * + * if order == 'F': + * for idx in range(ndim): # <<<<<<<<<<<<<< + * strides[idx] = stride + * stride *= shape[idx] + */ + __pyx_t_2 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_idx = __pyx_t_4; + + /* "View.MemoryView":1200 + * if order == 'F': + * for idx in range(ndim): + * strides[idx] = stride # <<<<<<<<<<<<<< + * stride *= shape[idx] + * else: + */ + (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; + + /* "View.MemoryView":1201 + * for idx in range(ndim): + * strides[idx] = stride + * stride *= shape[idx] # <<<<<<<<<<<<<< + * else: + * for idx in range(ndim - 1, -1, -1): + */ + __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); + } + + /* "View.MemoryView":1198 + * cdef int idx + * + * if order == 'F': # <<<<<<<<<<<<<< + * for idx in range(ndim): + * strides[idx] = stride + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1203 + * stride *= shape[idx] + * else: + * for idx in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< + * strides[idx] = stride + * stride *= shape[idx] + */ + /*else*/ { + for (__pyx_t_2 = (__pyx_v_ndim - 1); __pyx_t_2 > -1; __pyx_t_2-=1) { + __pyx_v_idx = __pyx_t_2; + + /* "View.MemoryView":1204 + * else: + * for idx in range(ndim - 1, -1, -1): + * strides[idx] = stride # <<<<<<<<<<<<<< + * stride *= shape[idx] + * + */ + (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; + + /* "View.MemoryView":1205 + * for idx in range(ndim - 1, -1, -1): + * strides[idx] = stride + * stride *= shape[idx] # <<<<<<<<<<<<<< + * + * return stride + */ + __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); + } + } + __pyx_L3:; + + /* "View.MemoryView":1207 + * stride *= shape[idx] + * + * return stride # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_data_to_temp') + */ + __pyx_r = __pyx_v_stride; + goto __pyx_L0; + + /* "View.MemoryView":1189 + * + * @cname('__pyx_fill_contig_strides_array') + * cdef Py_ssize_t fill_contig_strides_array( # <<<<<<<<<<<<<< + * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, + * int ndim, char order) nogil: + */ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1210 + * + * @cname('__pyx_memoryview_copy_data_to_temp') + * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *tmpslice, + * char order, + */ + +static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_tmpslice, char __pyx_v_order, int __pyx_v_ndim) { + int __pyx_v_i; + void *__pyx_v_result; + size_t __pyx_v_itemsize; + size_t __pyx_v_size; + void *__pyx_r; + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + struct __pyx_memoryview_obj *__pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":1221 + * cdef void *result + * + * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< + * cdef size_t size = slice_get_size(src, ndim) + * + */ + __pyx_t_1 = __pyx_v_src->memview->view.itemsize; + __pyx_v_itemsize = __pyx_t_1; + + /* "View.MemoryView":1222 + * + * cdef size_t itemsize = src.memview.view.itemsize + * cdef size_t size = slice_get_size(src, ndim) # <<<<<<<<<<<<<< + * + * result = malloc(size) + */ + __pyx_v_size = __pyx_memoryview_slice_get_size(__pyx_v_src, __pyx_v_ndim); + + /* "View.MemoryView":1224 + * cdef size_t size = slice_get_size(src, ndim) + * + * result = malloc(size) # <<<<<<<<<<<<<< + * if not result: + * _err(MemoryError, NULL) + */ + __pyx_v_result = malloc(__pyx_v_size); + + /* "View.MemoryView":1225 + * + * result = malloc(size) + * if not result: # <<<<<<<<<<<<<< + * _err(MemoryError, NULL) + * + */ + __pyx_t_2 = ((!(__pyx_v_result != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1226 + * result = malloc(size) + * if not result: + * _err(MemoryError, NULL) # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_3 = __pyx_memoryview_err(__pyx_builtin_MemoryError, NULL); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 1226, __pyx_L1_error) + + /* "View.MemoryView":1225 + * + * result = malloc(size) + * if not result: # <<<<<<<<<<<<<< + * _err(MemoryError, NULL) + * + */ + } + + /* "View.MemoryView":1229 + * + * + * tmpslice.data = result # <<<<<<<<<<<<<< + * tmpslice.memview = src.memview + * for i in range(ndim): + */ + __pyx_v_tmpslice->data = ((char *)__pyx_v_result); + + /* "View.MemoryView":1230 + * + * tmpslice.data = result + * tmpslice.memview = src.memview # <<<<<<<<<<<<<< + * for i in range(ndim): + * tmpslice.shape[i] = src.shape[i] + */ + __pyx_t_4 = __pyx_v_src->memview; + __pyx_v_tmpslice->memview = __pyx_t_4; + + /* "View.MemoryView":1231 + * tmpslice.data = result + * tmpslice.memview = src.memview + * for i in range(ndim): # <<<<<<<<<<<<<< + * tmpslice.shape[i] = src.shape[i] + * tmpslice.suboffsets[i] = -1 + */ + __pyx_t_3 = __pyx_v_ndim; + __pyx_t_5 = __pyx_t_3; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1232 + * tmpslice.memview = src.memview + * for i in range(ndim): + * tmpslice.shape[i] = src.shape[i] # <<<<<<<<<<<<<< + * tmpslice.suboffsets[i] = -1 + * + */ + (__pyx_v_tmpslice->shape[__pyx_v_i]) = (__pyx_v_src->shape[__pyx_v_i]); + + /* "View.MemoryView":1233 + * for i in range(ndim): + * tmpslice.shape[i] = src.shape[i] + * tmpslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< + * + * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, + */ + (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L; + } + + /* "View.MemoryView":1235 + * tmpslice.suboffsets[i] = -1 + * + * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, # <<<<<<<<<<<<<< + * ndim, order) + * + */ + (void)(__pyx_fill_contig_strides_array((&(__pyx_v_tmpslice->shape[0])), (&(__pyx_v_tmpslice->strides[0])), __pyx_v_itemsize, __pyx_v_ndim, __pyx_v_order)); + + /* "View.MemoryView":1239 + * + * + * for i in range(ndim): # <<<<<<<<<<<<<< + * if tmpslice.shape[i] == 1: + * tmpslice.strides[i] = 0 + */ + __pyx_t_3 = __pyx_v_ndim; + __pyx_t_5 = __pyx_t_3; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1240 + * + * for i in range(ndim): + * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< + * tmpslice.strides[i] = 0 + * + */ + __pyx_t_2 = (((__pyx_v_tmpslice->shape[__pyx_v_i]) == 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1241 + * for i in range(ndim): + * if tmpslice.shape[i] == 1: + * tmpslice.strides[i] = 0 # <<<<<<<<<<<<<< + * + * if slice_is_contig(src[0], order, ndim): + */ + (__pyx_v_tmpslice->strides[__pyx_v_i]) = 0; + + /* "View.MemoryView":1240 + * + * for i in range(ndim): + * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< + * tmpslice.strides[i] = 0 + * + */ + } + } + + /* "View.MemoryView":1243 + * tmpslice.strides[i] = 0 + * + * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< + * memcpy(result, src.data, size) + * else: + */ + __pyx_t_2 = (__pyx_memviewslice_is_contig((__pyx_v_src[0]), __pyx_v_order, __pyx_v_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1244 + * + * if slice_is_contig(src[0], order, ndim): + * memcpy(result, src.data, size) # <<<<<<<<<<<<<< + * else: + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) + */ + (void)(memcpy(__pyx_v_result, __pyx_v_src->data, __pyx_v_size)); + + /* "View.MemoryView":1243 + * tmpslice.strides[i] = 0 + * + * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< + * memcpy(result, src.data, size) + * else: + */ + goto __pyx_L9; + } + + /* "View.MemoryView":1246 + * memcpy(result, src.data, size) + * else: + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) # <<<<<<<<<<<<<< + * + * return result + */ + /*else*/ { + copy_strided_to_strided(__pyx_v_src, __pyx_v_tmpslice, __pyx_v_ndim, __pyx_v_itemsize); + } + __pyx_L9:; + + /* "View.MemoryView":1248 + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) + * + * return result # <<<<<<<<<<<<<< + * + * + */ + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "View.MemoryView":1210 + * + * @cname('__pyx_memoryview_copy_data_to_temp') + * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *tmpslice, + * char order, + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.copy_data_to_temp", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = NULL; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1253 + * + * @cname('__pyx_memoryview_err_extents') + * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % + */ + +static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent1, Py_ssize_t __pyx_v_extent2) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("_err_extents", 0); + + /* "View.MemoryView":1256 + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % + * (i, extent1, extent2)) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_err_dim') + */ + __pyx_t_1 = __Pyx_PyInt_From_int(__pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyInt_FromSsize_t(__pyx_v_extent1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyInt_FromSsize_t(__pyx_v_extent2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_1); + PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + + /* "View.MemoryView":1255 + * cdef int _err_extents(int i, Py_ssize_t extent1, + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % # <<<<<<<<<<<<<< + * (i, extent1, extent2)) + * + */ + __pyx_t_3 = __Pyx_PyString_Format(__pyx_kp_s_got_differing_extents_in_dimensi, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_CallOneArg(__pyx_builtin_ValueError, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 1255, __pyx_L1_error) + + /* "View.MemoryView":1253 + * + * @cname('__pyx_memoryview_err_extents') + * cdef int _err_extents(int i, Py_ssize_t extent1, # <<<<<<<<<<<<<< + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError("got differing extents in dimension %d (got %d and %d)" % + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView._err_extents", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "View.MemoryView":1259 + * + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii') % dim) + * + */ + +static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, char *__pyx_v_msg, int __pyx_v_dim) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("_err_dim", 0); + __Pyx_INCREF(__pyx_v_error); + + /* "View.MemoryView":1260 + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: + * raise error(msg.decode('ascii') % dim) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_err') + */ + __pyx_t_2 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyInt_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyUnicode_Format(__pyx_t_2, __pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_INCREF(__pyx_v_error); + __pyx_t_3 = __pyx_v_error; __pyx_t_2 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + if (likely(__pyx_t_2)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_3, function); + } + } + __pyx_t_1 = (__pyx_t_2) ? __Pyx_PyObject_Call2Args(__pyx_t_3, __pyx_t_2, __pyx_t_4) : __Pyx_PyObject_CallOneArg(__pyx_t_3, __pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1260, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(1, 1260, __pyx_L1_error) + + /* "View.MemoryView":1259 + * + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(object error, char *msg, int dim) except -1 with gil: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii') % dim) + * + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView._err_dim", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_XDECREF(__pyx_v_error); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "View.MemoryView":1263 + * + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< + * if msg != NULL: + * raise error(msg.decode('ascii')) + */ + +static int __pyx_memoryview_err(PyObject *__pyx_v_error, char *__pyx_v_msg) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("_err", 0); + __Pyx_INCREF(__pyx_v_error); + + /* "View.MemoryView":1264 + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: + * if msg != NULL: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii')) + * else: + */ + __pyx_t_1 = ((__pyx_v_msg != NULL) != 0); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":1265 + * cdef int _err(object error, char *msg) except -1 with gil: + * if msg != NULL: + * raise error(msg.decode('ascii')) # <<<<<<<<<<<<<< + * else: + * raise error + */ + __pyx_t_3 = __Pyx_decode_c_string(__pyx_v_msg, 0, strlen(__pyx_v_msg), NULL, NULL, PyUnicode_DecodeASCII); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_error); + __pyx_t_4 = __pyx_v_error; __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_4, function); + } + } + __pyx_t_2 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_4, __pyx_t_5, __pyx_t_3) : __Pyx_PyObject_CallOneArg(__pyx_t_4, __pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 1265, __pyx_L1_error) + + /* "View.MemoryView":1264 + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: + * if msg != NULL: # <<<<<<<<<<<<<< + * raise error(msg.decode('ascii')) + * else: + */ + } + + /* "View.MemoryView":1267 + * raise error(msg.decode('ascii')) + * else: + * raise error # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_contents') + */ + /*else*/ { + __Pyx_Raise(__pyx_v_error, 0, 0, 0); + __PYX_ERR(1, 1267, __pyx_L1_error) + } + + /* "View.MemoryView":1263 + * + * @cname('__pyx_memoryview_err') + * cdef int _err(object error, char *msg) except -1 with gil: # <<<<<<<<<<<<<< + * if msg != NULL: + * raise error(msg.decode('ascii')) + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView._err", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_XDECREF(__pyx_v_error); + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + return __pyx_r; +} + +/* "View.MemoryView":1270 + * + * @cname('__pyx_memoryview_copy_contents') + * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice dst, + * int src_ndim, int dst_ndim, + */ + +static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_memviewslice __pyx_v_dst, int __pyx_v_src_ndim, int __pyx_v_dst_ndim, int __pyx_v_dtype_is_object) { + void *__pyx_v_tmpdata; + size_t __pyx_v_itemsize; + int __pyx_v_i; + char __pyx_v_order; + int __pyx_v_broadcasting; + int __pyx_v_direct_copy; + __Pyx_memviewslice __pyx_v_tmp; + int __pyx_v_ndim; + int __pyx_r; + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + void *__pyx_t_7; + int __pyx_t_8; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":1278 + * Check for overlapping memory and verify the shapes. + * """ + * cdef void *tmpdata = NULL # <<<<<<<<<<<<<< + * cdef size_t itemsize = src.memview.view.itemsize + * cdef int i + */ + __pyx_v_tmpdata = NULL; + + /* "View.MemoryView":1279 + * """ + * cdef void *tmpdata = NULL + * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) + */ + __pyx_t_1 = __pyx_v_src.memview->view.itemsize; + __pyx_v_itemsize = __pyx_t_1; + + /* "View.MemoryView":1281 + * cdef size_t itemsize = src.memview.view.itemsize + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) # <<<<<<<<<<<<<< + * cdef bint broadcasting = False + * cdef bint direct_copy = False + */ + __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_src), __pyx_v_src_ndim); + + /* "View.MemoryView":1282 + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) + * cdef bint broadcasting = False # <<<<<<<<<<<<<< + * cdef bint direct_copy = False + * cdef __Pyx_memviewslice tmp + */ + __pyx_v_broadcasting = 0; + + /* "View.MemoryView":1283 + * cdef char order = get_best_order(&src, src_ndim) + * cdef bint broadcasting = False + * cdef bint direct_copy = False # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice tmp + * + */ + __pyx_v_direct_copy = 0; + + /* "View.MemoryView":1286 + * cdef __Pyx_memviewslice tmp + * + * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: + */ + __pyx_t_2 = ((__pyx_v_src_ndim < __pyx_v_dst_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1287 + * + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) # <<<<<<<<<<<<<< + * elif dst_ndim < src_ndim: + * broadcast_leading(&dst, dst_ndim, src_ndim) + */ + __pyx_memoryview_broadcast_leading((&__pyx_v_src), __pyx_v_src_ndim, __pyx_v_dst_ndim); + + /* "View.MemoryView":1286 + * cdef __Pyx_memviewslice tmp + * + * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1288 + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&dst, dst_ndim, src_ndim) + * + */ + __pyx_t_2 = ((__pyx_v_dst_ndim < __pyx_v_src_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1289 + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: + * broadcast_leading(&dst, dst_ndim, src_ndim) # <<<<<<<<<<<<<< + * + * cdef int ndim = max(src_ndim, dst_ndim) + */ + __pyx_memoryview_broadcast_leading((&__pyx_v_dst), __pyx_v_dst_ndim, __pyx_v_src_ndim); + + /* "View.MemoryView":1288 + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&dst, dst_ndim, src_ndim) + * + */ + } + __pyx_L3:; + + /* "View.MemoryView":1291 + * broadcast_leading(&dst, dst_ndim, src_ndim) + * + * cdef int ndim = max(src_ndim, dst_ndim) # <<<<<<<<<<<<<< + * + * for i in range(ndim): + */ + __pyx_t_3 = __pyx_v_dst_ndim; + __pyx_t_4 = __pyx_v_src_ndim; + if (((__pyx_t_3 > __pyx_t_4) != 0)) { + __pyx_t_5 = __pyx_t_3; + } else { + __pyx_t_5 = __pyx_t_4; + } + __pyx_v_ndim = __pyx_t_5; + + /* "View.MemoryView":1293 + * cdef int ndim = max(src_ndim, dst_ndim) + * + * for i in range(ndim): # <<<<<<<<<<<<<< + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: + */ + __pyx_t_5 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_5; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1294 + * + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< + * if src.shape[i] == 1: + * broadcasting = True + */ + __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) != (__pyx_v_dst.shape[__pyx_v_i])) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1295 + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: # <<<<<<<<<<<<<< + * broadcasting = True + * src.strides[i] = 0 + */ + __pyx_t_2 = (((__pyx_v_src.shape[__pyx_v_i]) == 1) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1296 + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: + * broadcasting = True # <<<<<<<<<<<<<< + * src.strides[i] = 0 + * else: + */ + __pyx_v_broadcasting = 1; + + /* "View.MemoryView":1297 + * if src.shape[i] == 1: + * broadcasting = True + * src.strides[i] = 0 # <<<<<<<<<<<<<< + * else: + * _err_extents(i, dst.shape[i], src.shape[i]) + */ + (__pyx_v_src.strides[__pyx_v_i]) = 0; + + /* "View.MemoryView":1295 + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: # <<<<<<<<<<<<<< + * broadcasting = True + * src.strides[i] = 0 + */ + goto __pyx_L7; + } + + /* "View.MemoryView":1299 + * src.strides[i] = 0 + * else: + * _err_extents(i, dst.shape[i], src.shape[i]) # <<<<<<<<<<<<<< + * + * if src.suboffsets[i] >= 0: + */ + /*else*/ { + __pyx_t_6 = __pyx_memoryview_err_extents(__pyx_v_i, (__pyx_v_dst.shape[__pyx_v_i]), (__pyx_v_src.shape[__pyx_v_i])); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1299, __pyx_L1_error) + } + __pyx_L7:; + + /* "View.MemoryView":1294 + * + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< + * if src.shape[i] == 1: + * broadcasting = True + */ + } + + /* "View.MemoryView":1301 + * _err_extents(i, dst.shape[i], src.shape[i]) + * + * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + */ + __pyx_t_2 = (((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1302 + * + * if src.suboffsets[i] >= 0: + * _err_dim(ValueError, "Dimension %d is not direct", i) # <<<<<<<<<<<<<< + * + * if slices_overlap(&src, &dst, ndim, itemsize): + */ + __pyx_t_6 = __pyx_memoryview_err_dim(__pyx_builtin_ValueError, ((char *)"Dimension %d is not direct"), __pyx_v_i); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1302, __pyx_L1_error) + + /* "View.MemoryView":1301 + * _err_extents(i, dst.shape[i], src.shape[i]) + * + * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + */ + } + } + + /* "View.MemoryView":1304 + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< + * + * if not slice_is_contig(src, order, ndim): + */ + __pyx_t_2 = (__pyx_slices_overlap((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1306 + * if slices_overlap(&src, &dst, ndim, itemsize): + * + * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< + * order = get_best_order(&dst, ndim) + * + */ + __pyx_t_2 = ((!(__pyx_memviewslice_is_contig(__pyx_v_src, __pyx_v_order, __pyx_v_ndim) != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1307 + * + * if not slice_is_contig(src, order, ndim): + * order = get_best_order(&dst, ndim) # <<<<<<<<<<<<<< + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) + */ + __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim); + + /* "View.MemoryView":1306 + * if slices_overlap(&src, &dst, ndim, itemsize): + * + * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< + * order = get_best_order(&dst, ndim) + * + */ + } + + /* "View.MemoryView":1309 + * order = get_best_order(&dst, ndim) + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) # <<<<<<<<<<<<<< + * src = tmp + * + */ + __pyx_t_7 = __pyx_memoryview_copy_data_to_temp((&__pyx_v_src), (&__pyx_v_tmp), __pyx_v_order, __pyx_v_ndim); if (unlikely(__pyx_t_7 == ((void *)NULL))) __PYX_ERR(1, 1309, __pyx_L1_error) + __pyx_v_tmpdata = __pyx_t_7; + + /* "View.MemoryView":1310 + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) + * src = tmp # <<<<<<<<<<<<<< + * + * if not broadcasting: + */ + __pyx_v_src = __pyx_v_tmp; + + /* "View.MemoryView":1304 + * _err_dim(ValueError, "Dimension %d is not direct", i) + * + * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< + * + * if not slice_is_contig(src, order, ndim): + */ + } + + /* "View.MemoryView":1312 + * src = tmp + * + * if not broadcasting: # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = ((!(__pyx_v_broadcasting != 0)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1315 + * + * + * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): + */ + __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'C', __pyx_v_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1316 + * + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) # <<<<<<<<<<<<<< + * elif slice_is_contig(src, 'F', ndim): + * direct_copy = slice_is_contig(dst, 'F', ndim) + */ + __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'C', __pyx_v_ndim); + + /* "View.MemoryView":1315 + * + * + * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): + */ + goto __pyx_L12; + } + + /* "View.MemoryView":1317 + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + */ + __pyx_t_2 = (__pyx_memviewslice_is_contig(__pyx_v_src, 'F', __pyx_v_ndim) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1318 + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): + * direct_copy = slice_is_contig(dst, 'F', ndim) # <<<<<<<<<<<<<< + * + * if direct_copy: + */ + __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'F', __pyx_v_ndim); + + /* "View.MemoryView":1317 + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + */ + } + __pyx_L12:; + + /* "View.MemoryView":1320 + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + * if direct_copy: # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + __pyx_t_2 = (__pyx_v_direct_copy != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1322 + * if direct_copy: + * + * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1323 + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, True) + * free(tmpdata) + */ + (void)(memcpy(__pyx_v_dst.data, __pyx_v_src.data, __pyx_memoryview_slice_get_size((&__pyx_v_src), __pyx_v_ndim))); + + /* "View.MemoryView":1324 + * refcount_copying(&dst, dtype_is_object, ndim, False) + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * free(tmpdata) + * return 0 + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1325 + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, True) + * free(tmpdata) # <<<<<<<<<<<<<< + * return 0 + * + */ + free(__pyx_v_tmpdata); + + /* "View.MemoryView":1326 + * refcount_copying(&dst, dtype_is_object, ndim, True) + * free(tmpdata) + * return 0 # <<<<<<<<<<<<<< + * + * if order == 'F' == get_best_order(&dst, ndim): + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":1320 + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + * if direct_copy: # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + } + + /* "View.MemoryView":1312 + * src = tmp + * + * if not broadcasting: # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":1328 + * return 0 + * + * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_2 = (__pyx_v_order == 'F'); + if (__pyx_t_2) { + __pyx_t_2 = ('F' == __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim)); + } + __pyx_t_8 = (__pyx_t_2 != 0); + if (__pyx_t_8) { + + /* "View.MemoryView":1331 + * + * + * transpose_memslice(&src) # <<<<<<<<<<<<<< + * transpose_memslice(&dst) + * + */ + __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_src)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1331, __pyx_L1_error) + + /* "View.MemoryView":1332 + * + * transpose_memslice(&src) + * transpose_memslice(&dst) # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + */ + __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_dst)); if (unlikely(__pyx_t_5 == ((int)0))) __PYX_ERR(1, 1332, __pyx_L1_error) + + /* "View.MemoryView":1328 + * return 0 + * + * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< + * + * + */ + } + + /* "View.MemoryView":1334 + * transpose_memslice(&dst) + * + * refcount_copying(&dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * copy_strided_to_strided(&src, &dst, ndim, itemsize) + * refcount_copying(&dst, dtype_is_object, ndim, True) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1335 + * + * refcount_copying(&dst, dtype_is_object, ndim, False) + * copy_strided_to_strided(&src, &dst, ndim, itemsize) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, True) + * + */ + copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); + + /* "View.MemoryView":1336 + * refcount_copying(&dst, dtype_is_object, ndim, False) + * copy_strided_to_strided(&src, &dst, ndim, itemsize) + * refcount_copying(&dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * + * free(tmpdata) + */ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1338 + * refcount_copying(&dst, dtype_is_object, ndim, True) + * + * free(tmpdata) # <<<<<<<<<<<<<< + * return 0 + * + */ + free(__pyx_v_tmpdata); + + /* "View.MemoryView":1339 + * + * free(tmpdata) + * return 0 # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_broadcast_leading') + */ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":1270 + * + * @cname('__pyx_memoryview_copy_contents') + * cdef int memoryview_copy_contents(__Pyx_memviewslice src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice dst, + * int src_ndim, int dst_ndim, + */ + + /* function exit code */ + __pyx_L1_error:; + { + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_AddTraceback("View.MemoryView.memoryview_copy_contents", __pyx_clineno, __pyx_lineno, __pyx_filename); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif + } + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1342 + * + * @cname('__pyx_memoryview_broadcast_leading') + * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< + * int ndim, + * int ndim_other) nogil: + */ + +static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim, int __pyx_v_ndim_other) { + int __pyx_v_i; + int __pyx_v_offset; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + + /* "View.MemoryView":1346 + * int ndim_other) nogil: + * cdef int i + * cdef int offset = ndim_other - ndim # <<<<<<<<<<<<<< + * + * for i in range(ndim - 1, -1, -1): + */ + __pyx_v_offset = (__pyx_v_ndim_other - __pyx_v_ndim); + + /* "View.MemoryView":1348 + * cdef int offset = ndim_other - ndim + * + * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = mslice.strides[i] + */ + for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { + __pyx_v_i = __pyx_t_1; + + /* "View.MemoryView":1349 + * + * for i in range(ndim - 1, -1, -1): + * mslice.shape[i + offset] = mslice.shape[i] # <<<<<<<<<<<<<< + * mslice.strides[i + offset] = mslice.strides[i] + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] + */ + (__pyx_v_mslice->shape[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->shape[__pyx_v_i]); + + /* "View.MemoryView":1350 + * for i in range(ndim - 1, -1, -1): + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = mslice.strides[i] # <<<<<<<<<<<<<< + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] + * + */ + (__pyx_v_mslice->strides[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->strides[__pyx_v_i]); + + /* "View.MemoryView":1351 + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = mslice.strides[i] + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] # <<<<<<<<<<<<<< + * + * for i in range(offset): + */ + (__pyx_v_mslice->suboffsets[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->suboffsets[__pyx_v_i]); + } + + /* "View.MemoryView":1353 + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] + * + * for i in range(offset): # <<<<<<<<<<<<<< + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] + */ + __pyx_t_1 = __pyx_v_offset; + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_i = __pyx_t_3; + + /* "View.MemoryView":1354 + * + * for i in range(offset): + * mslice.shape[i] = 1 # <<<<<<<<<<<<<< + * mslice.strides[i] = mslice.strides[0] + * mslice.suboffsets[i] = -1 + */ + (__pyx_v_mslice->shape[__pyx_v_i]) = 1; + + /* "View.MemoryView":1355 + * for i in range(offset): + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] # <<<<<<<<<<<<<< + * mslice.suboffsets[i] = -1 + * + */ + (__pyx_v_mslice->strides[__pyx_v_i]) = (__pyx_v_mslice->strides[0]); + + /* "View.MemoryView":1356 + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] + * mslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< + * + * + */ + (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L; + } + + /* "View.MemoryView":1342 + * + * @cname('__pyx_memoryview_broadcast_leading') + * cdef void broadcast_leading(__Pyx_memviewslice *mslice, # <<<<<<<<<<<<<< + * int ndim, + * int ndim_other) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1364 + * + * @cname('__pyx_memoryview_refcount_copying') + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< + * int ndim, bint inc) nogil: + * + */ + +static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_dtype_is_object, int __pyx_v_ndim, int __pyx_v_inc) { + int __pyx_t_1; + + /* "View.MemoryView":1368 + * + * + * if dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, + * dst.strides, ndim, inc) + */ + __pyx_t_1 = (__pyx_v_dtype_is_object != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1369 + * + * if dtype_is_object: + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, # <<<<<<<<<<<<<< + * dst.strides, ndim, inc) + * + */ + __pyx_memoryview_refcount_objects_in_slice_with_gil(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_inc); + + /* "View.MemoryView":1368 + * + * + * if dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, + * dst.strides, ndim, inc) + */ + } + + /* "View.MemoryView":1364 + * + * @cname('__pyx_memoryview_refcount_copying') + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, # <<<<<<<<<<<<<< + * int ndim, bint inc) nogil: + * + */ + + /* function exit code */ +} + +/* "View.MemoryView":1373 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') + * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * bint inc) with gil: + */ + +static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { + __Pyx_RefNannyDeclarations + #ifdef WITH_THREAD + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + #endif + __Pyx_RefNannySetupContext("refcount_objects_in_slice_with_gil", 0); + + /* "View.MemoryView":1376 + * Py_ssize_t *strides, int ndim, + * bint inc) with gil: + * refcount_objects_in_slice(data, shape, strides, ndim, inc) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') + */ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, __pyx_v_shape, __pyx_v_strides, __pyx_v_ndim, __pyx_v_inc); + + /* "View.MemoryView":1373 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') + * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * bint inc) with gil: + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + #ifdef WITH_THREAD + __Pyx_PyGILState_Release(__pyx_gilstate_save); + #endif +} + +/* "View.MemoryView":1379 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') + * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, bint inc): + * cdef Py_ssize_t i + */ + +static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + __Pyx_RefNannySetupContext("refcount_objects_in_slice", 0); + + /* "View.MemoryView":1383 + * cdef Py_ssize_t i + * + * for i in range(shape[0]): # <<<<<<<<<<<<<< + * if ndim == 1: + * if inc: + */ + __pyx_t_1 = (__pyx_v_shape[0]); + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_i = __pyx_t_3; + + /* "View.MemoryView":1384 + * + * for i in range(shape[0]): + * if ndim == 1: # <<<<<<<<<<<<<< + * if inc: + * Py_INCREF(( data)[0]) + */ + __pyx_t_4 = ((__pyx_v_ndim == 1) != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":1385 + * for i in range(shape[0]): + * if ndim == 1: + * if inc: # <<<<<<<<<<<<<< + * Py_INCREF(( data)[0]) + * else: + */ + __pyx_t_4 = (__pyx_v_inc != 0); + if (__pyx_t_4) { + + /* "View.MemoryView":1386 + * if ndim == 1: + * if inc: + * Py_INCREF(( data)[0]) # <<<<<<<<<<<<<< + * else: + * Py_DECREF(( data)[0]) + */ + Py_INCREF((((PyObject **)__pyx_v_data)[0])); + + /* "View.MemoryView":1385 + * for i in range(shape[0]): + * if ndim == 1: + * if inc: # <<<<<<<<<<<<<< + * Py_INCREF(( data)[0]) + * else: + */ + goto __pyx_L6; + } + + /* "View.MemoryView":1388 + * Py_INCREF(( data)[0]) + * else: + * Py_DECREF(( data)[0]) # <<<<<<<<<<<<<< + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, + */ + /*else*/ { + Py_DECREF((((PyObject **)__pyx_v_data)[0])); + } + __pyx_L6:; + + /* "View.MemoryView":1384 + * + * for i in range(shape[0]): + * if ndim == 1: # <<<<<<<<<<<<<< + * if inc: + * Py_INCREF(( data)[0]) + */ + goto __pyx_L5; + } + + /* "View.MemoryView":1390 + * Py_DECREF(( data)[0]) + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< + * ndim - 1, inc) + * + */ + /*else*/ { + + /* "View.MemoryView":1391 + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, + * ndim - 1, inc) # <<<<<<<<<<<<<< + * + * data += strides[0] + */ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_inc); + } + __pyx_L5:; + + /* "View.MemoryView":1393 + * ndim - 1, inc) + * + * data += strides[0] # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_data = (__pyx_v_data + (__pyx_v_strides[0])); + } + + /* "View.MemoryView":1379 + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') + * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, bint inc): + * cdef Py_ssize_t i + */ + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +/* "View.MemoryView":1399 + * + * @cname('__pyx_memoryview_slice_assign_scalar') + * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< + * size_t itemsize, void *item, + * bint dtype_is_object) nogil: + */ + +static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item, int __pyx_v_dtype_is_object) { + + /* "View.MemoryView":1402 + * size_t itemsize, void *item, + * bint dtype_is_object) nogil: + * refcount_copying(dst, dtype_is_object, ndim, False) # <<<<<<<<<<<<<< + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, + * itemsize, item) + */ + __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1403 + * bint dtype_is_object) nogil: + * refcount_copying(dst, dtype_is_object, ndim, False) + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, # <<<<<<<<<<<<<< + * itemsize, item) + * refcount_copying(dst, dtype_is_object, ndim, True) + */ + __pyx_memoryview__slice_assign_scalar(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_itemsize, __pyx_v_item); + + /* "View.MemoryView":1405 + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, + * itemsize, item) + * refcount_copying(dst, dtype_is_object, ndim, True) # <<<<<<<<<<<<<< + * + * + */ + __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1399 + * + * @cname('__pyx_memoryview_slice_assign_scalar') + * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, # <<<<<<<<<<<<<< + * size_t itemsize, void *item, + * bint dtype_is_object) nogil: + */ + + /* function exit code */ +} + +/* "View.MemoryView":1409 + * + * @cname('__pyx_memoryview__slice_assign_scalar') + * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * size_t itemsize, void *item) nogil: + */ + +static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + Py_ssize_t __pyx_v_stride; + Py_ssize_t __pyx_v_extent; + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + + /* "View.MemoryView":1413 + * size_t itemsize, void *item) nogil: + * cdef Py_ssize_t i + * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t extent = shape[0] + * + */ + __pyx_v_stride = (__pyx_v_strides[0]); + + /* "View.MemoryView":1414 + * cdef Py_ssize_t i + * cdef Py_ssize_t stride = strides[0] + * cdef Py_ssize_t extent = shape[0] # <<<<<<<<<<<<<< + * + * if ndim == 1: + */ + __pyx_v_extent = (__pyx_v_shape[0]); + + /* "View.MemoryView":1416 + * cdef Py_ssize_t extent = shape[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * for i in range(extent): + * memcpy(data, item, itemsize) + */ + __pyx_t_1 = ((__pyx_v_ndim == 1) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1417 + * + * if ndim == 1: + * for i in range(extent): # <<<<<<<<<<<<<< + * memcpy(data, item, itemsize) + * data += stride + */ + __pyx_t_2 = __pyx_v_extent; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1418 + * if ndim == 1: + * for i in range(extent): + * memcpy(data, item, itemsize) # <<<<<<<<<<<<<< + * data += stride + * else: + */ + (void)(memcpy(__pyx_v_data, __pyx_v_item, __pyx_v_itemsize)); + + /* "View.MemoryView":1419 + * for i in range(extent): + * memcpy(data, item, itemsize) + * data += stride # <<<<<<<<<<<<<< + * else: + * for i in range(extent): + */ + __pyx_v_data = (__pyx_v_data + __pyx_v_stride); + } + + /* "View.MemoryView":1416 + * cdef Py_ssize_t extent = shape[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * for i in range(extent): + * memcpy(data, item, itemsize) + */ + goto __pyx_L3; + } + + /* "View.MemoryView":1421 + * data += stride + * else: + * for i in range(extent): # <<<<<<<<<<<<<< + * _slice_assign_scalar(data, shape + 1, strides + 1, + * ndim - 1, itemsize, item) + */ + /*else*/ { + __pyx_t_2 = __pyx_v_extent; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1422 + * else: + * for i in range(extent): + * _slice_assign_scalar(data, shape + 1, strides + 1, # <<<<<<<<<<<<<< + * ndim - 1, itemsize, item) + * data += stride + */ + __pyx_memoryview__slice_assign_scalar(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize, __pyx_v_item); + + /* "View.MemoryView":1424 + * _slice_assign_scalar(data, shape + 1, strides + 1, + * ndim - 1, itemsize, item) + * data += stride # <<<<<<<<<<<<<< + * + * + */ + __pyx_v_data = (__pyx_v_data + __pyx_v_stride); + } + } + __pyx_L3:; + + /* "View.MemoryView":1409 + * + * @cname('__pyx_memoryview__slice_assign_scalar') + * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, # <<<<<<<<<<<<<< + * Py_ssize_t *strides, int ndim, + * size_t itemsize, void *item) nogil: + */ + + /* function exit code */ +} + +/* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static PyMethodDef __pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum = {"__pyx_unpickle_Enum", (PyCFunction)(void*)(PyCFunctionWithKeywords)__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum, METH_VARARGS|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum (wrapper)", 0); + { + static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_pyx_type,&__pyx_n_s_pyx_checksum,&__pyx_n_s_pyx_state,0}; + PyObject* values[3] = {0,0,0}; + if (unlikely(__pyx_kwds)) { + Py_ssize_t kw_args; + const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args); + switch (pos_args) { + case 3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + CYTHON_FALLTHROUGH; + case 2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + CYTHON_FALLTHROUGH; + case 1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + kw_args = PyDict_Size(__pyx_kwds); + switch (pos_args) { + case 0: + if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_type)) != 0)) kw_args--; + else goto __pyx_L5_argtuple_error; + CYTHON_FALLTHROUGH; + case 1: + if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_checksum)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 1); __PYX_ERR(1, 1, __pyx_L3_error) + } + CYTHON_FALLTHROUGH; + case 2: + if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_pyx_state)) != 0)) kw_args--; + else { + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, 2); __PYX_ERR(1, 1, __pyx_L3_error) + } + } + if (unlikely(kw_args > 0)) { + if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_unpickle_Enum") < 0)) __PYX_ERR(1, 1, __pyx_L3_error) + } + } else if (PyTuple_GET_SIZE(__pyx_args) != 3) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = PyTuple_GET_ITEM(__pyx_args, 0); + values[1] = PyTuple_GET_ITEM(__pyx_args, 1); + values[2] = PyTuple_GET_ITEM(__pyx_args, 2); + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyInt_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_v___pyx_state = values[2]; + } + goto __pyx_L4_argument_unpacking_done; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(1, 1, __pyx_L3_error) + __pyx_L3_error:; + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_PickleError = 0; + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 0); + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = (__Pyx_PySequence_ContainsTF(__pyx_t_1, __pyx_tuple__19, Py_NE)); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = (__pyx_t_2 != 0); + if (__pyx_t_3) { + + /* "(tree fragment)":5 + * cdef object __pyx_result + * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): + * from pickle import PickleError as __pyx_PickleError # <<<<<<<<<<<<<< + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) + */ + __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_n_s_PickleError); + __Pyx_GIVEREF(__pyx_n_s_PickleError); + PyList_SET_ITEM(__pyx_t_1, 0, __pyx_n_s_PickleError); + __pyx_t_4 = __Pyx_Import(__pyx_n_s_pickle, __pyx_t_1, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_ImportFrom(__pyx_t_4, __pyx_n_s_PickleError); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_t_1); + __pyx_v___pyx_PickleError = __pyx_t_1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":6 + * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) # <<<<<<<<<<<<<< + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: + */ + __pyx_t_1 = __Pyx_PyInt_From_long(__pyx_v___pyx_checksum); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyString_Format(__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_t_1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_INCREF(__pyx_v___pyx_PickleError); + __pyx_t_1 = __pyx_v___pyx_PickleError; __pyx_t_6 = NULL; + if (CYTHON_UNPACK_METHODS && unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_6)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_6) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_6, __pyx_t_5) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(1, 6, __pyx_L1_error) + + /* "(tree fragment)":4 + * cdef object __pyx_PickleError + * cdef object __pyx_result + * if __pyx_checksum not in (0xb068931, 0x82a3537, 0x6ae9995): # <<<<<<<<<<<<<< + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + */ + } + + /* "(tree fragment)":7 + * from pickle import PickleError as __pyx_PickleError + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + */ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_MemviewEnum_type), __pyx_n_s_new); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + if (likely(__pyx_t_5)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_1, function); + } + } + __pyx_t_4 = (__pyx_t_5) ? __Pyx_PyObject_Call2Args(__pyx_t_1, __pyx_t_5, __pyx_v___pyx_type) : __Pyx_PyObject_CallOneArg(__pyx_t_1, __pyx_v___pyx_type); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result = __pyx_t_4; + __pyx_t_4 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + __pyx_t_3 = (__pyx_v___pyx_state != Py_None); + __pyx_t_2 = (__pyx_t_3 != 0); + if (__pyx_t_2) { + + /* "(tree fragment)":9 + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + */ + if (!(likely(PyTuple_CheckExact(__pyx_v___pyx_state))||((__pyx_v___pyx_state) == Py_None)||((void)PyErr_Format(PyExc_TypeError, "Expected %.16s, got %.200s", "tuple", Py_TYPE(__pyx_v___pyx_state)->tp_name), 0))) __PYX_ERR(1, 9, __pyx_L1_error) + __pyx_t_4 = __pyx_unpickle_Enum__set_state(((struct __pyx_MemviewEnum_obj *)__pyx_v___pyx_result), ((PyObject*)__pyx_v___pyx_state)); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":8 + * raise __pyx_PickleError("Incompatible checksums (0x%x vs (0xb068931, 0x82a3537, 0x6ae9995) = (name))" % __pyx_checksum) + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + */ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] + */ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_PickleError); + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + +static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 0); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] # <<<<<<<<<<<<<< + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 12, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->name); + __Pyx_DECREF(__pyx_v___pyx_result->name); + __pyx_v___pyx_result->name = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 13, __pyx_L1_error) + } + __pyx_t_3 = PyTuple_GET_SIZE(__pyx_v___pyx_state); if (unlikely(__pyx_t_3 == ((Py_ssize_t)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_4 = ((__pyx_t_3 > 1) != 0); + if (__pyx_t_4) { + } else { + __pyx_t_2 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_HasAttr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + __pyx_t_5 = (__pyx_t_4 != 0); + __pyx_t_2 = __pyx_t_5; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":14 + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + * __pyx_result.__dict__.update(__pyx_state[1]) # <<<<<<<<<<<<<< + */ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v___pyx_result), __pyx_n_s_dict); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_n_s_update); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(1, 14, __pyx_L1_error) + } + __pyx_t_6 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = NULL; + if (CYTHON_UNPACK_METHODS && likely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + if (likely(__pyx_t_8)) { + PyObject* function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(function); + __Pyx_DECREF_SET(__pyx_t_7, function); + } + } + __pyx_t_1 = (__pyx_t_8) ? __Pyx_PyObject_Call2Args(__pyx_t_7, __pyx_t_8, __pyx_t_6) : __Pyx_PyObject_CallOneArg(__pyx_t_7, __pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 14, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): # <<<<<<<<<<<<<< + * __pyx_result.__dict__.update(__pyx_state[1]) + */ + } + + /* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static struct __pyx_vtabstruct_array __pyx_vtable_array; + +static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_array_obj *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_array_obj *)o); + p->__pyx_vtab = __pyx_vtabptr_array; + p->mode = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_format = ((PyObject*)Py_None); Py_INCREF(Py_None); + if (unlikely(__pyx_array___cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_array(PyObject *o) { + struct __pyx_array_obj *p = (struct __pyx_array_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && (!PyType_IS_GC(Py_TYPE(o)) || !_PyGC_FINALIZED(o))) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_array___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->mode); + Py_CLEAR(p->_format); + (*Py_TYPE(o)->tp_free)(o); +} +static PyObject *__pyx_sq_item_array(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_array(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_array___setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyObject *__pyx_tp_getattro_array(PyObject *o, PyObject *n) { + PyObject *v = __Pyx_PyObject_GenericGetAttr(o, n); + if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + v = __pyx_array___getattr__(o, n); + } + return v; +} + +static PyObject *__pyx_getprop___pyx_array_memview(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(o); +} + +static PyMethodDef __pyx_methods_array[] = { + {"__getattr__", (PyCFunction)__pyx_array___getattr__, METH_O|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_array_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_array_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_array[] = { + {(char *)"memview", __pyx_getprop___pyx_array_memview, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_array = { + __pyx_array___len__, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_array, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_array = { + __pyx_array___len__, /*mp_length*/ + __pyx_array___getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_array, /*mp_ass_subscript*/ +}; + +static PyBufferProcs __pyx_tp_as_buffer_array = { + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getreadbuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getwritebuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getsegcount*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getcharbuffer*/ + #endif + __pyx_array_getbuffer, /*bf_getbuffer*/ + 0, /*bf_releasebuffer*/ +}; + +static PyTypeObject __pyx_type___pyx_array = { + PyVarObject_HEAD_INIT(0, 0) + "zoo.board_games.tictactoe.envs.legal_actions_cython.array", /*tp_name*/ + sizeof(struct __pyx_array_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_array, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_array, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_array, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + __pyx_tp_getattro_array, /*tp_getattro*/ + 0, /*tp_setattro*/ + &__pyx_tp_as_buffer_array, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_array, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_array, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_array, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + 0, /*tp_pypy_flags*/ + #endif +}; + +static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_MemviewEnum_obj *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_MemviewEnum_obj *)o); + p->name = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_Enum(PyObject *o) { + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->name); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_Enum(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + if (p->name) { + e = (*v)(p->name, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_Enum(PyObject *o) { + PyObject* tmp; + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + tmp = ((PyObject*)p->name); + p->name = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyMethodDef __pyx_methods_Enum[] = { + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_MemviewEnum_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type___pyx_MemviewEnum = { + PyVarObject_HEAD_INIT(0, 0) + "zoo.board_games.tictactoe.envs.legal_actions_cython.Enum", /*tp_name*/ + sizeof(struct __pyx_MemviewEnum_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_Enum, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_MemviewEnum___repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_Enum, /*tp_traverse*/ + __pyx_tp_clear_Enum, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_Enum, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + __pyx_MemviewEnum___init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_Enum, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + 0, /*tp_pypy_flags*/ + #endif +}; +static struct __pyx_vtabstruct_memoryview __pyx_vtable_memoryview; + +static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_memoryview_obj *p; + PyObject *o; + if (likely((t->tp_flags & Py_TPFLAGS_IS_ABSTRACT) == 0)) { + o = (*t->tp_alloc)(t, 0); + } else { + o = (PyObject *) PyBaseObject_Type.tp_new(t, __pyx_empty_tuple, 0); + } + if (unlikely(!o)) return 0; + p = ((struct __pyx_memoryview_obj *)o); + p->__pyx_vtab = __pyx_vtabptr_memoryview; + p->obj = Py_None; Py_INCREF(Py_None); + p->_size = Py_None; Py_INCREF(Py_None); + p->_array_interface = Py_None; Py_INCREF(Py_None); + p->view.obj = NULL; + if (unlikely(__pyx_memoryview___cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_memoryview(PyObject *o) { + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_memoryview___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->obj); + Py_CLEAR(p->_size); + Py_CLEAR(p->_array_interface); + (*Py_TYPE(o)->tp_free)(o); +} + +static int __pyx_tp_traverse_memoryview(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + if (p->obj) { + e = (*v)(p->obj, a); if (e) return e; + } + if (p->_size) { + e = (*v)(p->_size, a); if (e) return e; + } + if (p->_array_interface) { + e = (*v)(p->_array_interface, a); if (e) return e; + } + if (p->view.obj) { + e = (*v)(p->view.obj, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_memoryview(PyObject *o) { + PyObject* tmp; + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + tmp = ((PyObject*)p->obj); + p->obj = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_size); + p->_size = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_array_interface); + p->_array_interface = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + Py_CLEAR(p->view.obj); + return 0; +} +static PyObject *__pyx_sq_item_memoryview(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyInt_FromSsize_t(i); if(!x) return 0; + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_memoryview(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_memoryview___setitem__(o, i, v); + } + else { + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by %.200s", Py_TYPE(o)->tp_name); + return -1; + } +} + +static PyObject *__pyx_getprop___pyx_memoryview_T(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_base(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_shape(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_strides(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_suboffsets(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_ndim(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_itemsize(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_nbytes(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_size(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(o); +} + +static PyMethodDef __pyx_methods_memoryview[] = { + {"is_c_contig", (PyCFunction)__pyx_memoryview_is_c_contig, METH_NOARGS, 0}, + {"is_f_contig", (PyCFunction)__pyx_memoryview_is_f_contig, METH_NOARGS, 0}, + {"copy", (PyCFunction)__pyx_memoryview_copy, METH_NOARGS, 0}, + {"copy_fortran", (PyCFunction)__pyx_memoryview_copy_fortran, METH_NOARGS, 0}, + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryview_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_memoryview[] = { + {(char *)"T", __pyx_getprop___pyx_memoryview_T, 0, (char *)0, 0}, + {(char *)"base", __pyx_getprop___pyx_memoryview_base, 0, (char *)0, 0}, + {(char *)"shape", __pyx_getprop___pyx_memoryview_shape, 0, (char *)0, 0}, + {(char *)"strides", __pyx_getprop___pyx_memoryview_strides, 0, (char *)0, 0}, + {(char *)"suboffsets", __pyx_getprop___pyx_memoryview_suboffsets, 0, (char *)0, 0}, + {(char *)"ndim", __pyx_getprop___pyx_memoryview_ndim, 0, (char *)0, 0}, + {(char *)"itemsize", __pyx_getprop___pyx_memoryview_itemsize, 0, (char *)0, 0}, + {(char *)"nbytes", __pyx_getprop___pyx_memoryview_nbytes, 0, (char *)0, 0}, + {(char *)"size", __pyx_getprop___pyx_memoryview_size, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PySequenceMethods __pyx_tp_as_sequence_memoryview = { + __pyx_memoryview___len__, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_memoryview, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_memoryview = { + __pyx_memoryview___len__, /*mp_length*/ + __pyx_memoryview___getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_memoryview, /*mp_ass_subscript*/ +}; + +static PyBufferProcs __pyx_tp_as_buffer_memoryview = { + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getreadbuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getwritebuffer*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getsegcount*/ + #endif + #if PY_MAJOR_VERSION < 3 + 0, /*bf_getcharbuffer*/ + #endif + __pyx_memoryview_getbuffer, /*bf_getbuffer*/ + 0, /*bf_releasebuffer*/ +}; + +static PyTypeObject __pyx_type___pyx_memoryview = { + PyVarObject_HEAD_INIT(0, 0) + "zoo.board_games.tictactoe.envs.legal_actions_cython.memoryview", /*tp_name*/ + sizeof(struct __pyx_memoryview_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_memoryview, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + __pyx_memoryview___repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_memoryview, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_memoryview, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + __pyx_memoryview___str__, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + &__pyx_tp_as_buffer_memoryview, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_memoryview, /*tp_traverse*/ + __pyx_tp_clear_memoryview, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_memoryview, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_memoryview, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_memoryview, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + 0, /*tp_pypy_flags*/ + #endif +}; +static struct __pyx_vtabstruct__memoryviewslice __pyx_vtable__memoryviewslice; + +static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_memoryviewslice_obj *p; + PyObject *o = __pyx_tp_new_memoryview(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_memoryviewslice_obj *)o); + p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_memoryview*)__pyx_vtabptr__memoryviewslice; + p->from_object = Py_None; Py_INCREF(Py_None); + p->from_slice.memview = NULL; + return o; +} + +static void __pyx_tp_dealloc__memoryviewslice(PyObject *o) { + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyType_HasFeature(Py_TYPE(o), Py_TPFLAGS_HAVE_FINALIZE) && Py_TYPE(o)->tp_finalize) && !_PyGC_FINALIZED(o)) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_memoryviewslice___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->from_object); + PyObject_GC_Track(o); + __pyx_tp_dealloc_memoryview(o); +} + +static int __pyx_tp_traverse__memoryviewslice(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + e = __pyx_tp_traverse_memoryview(o, v, a); if (e) return e; + if (p->from_object) { + e = (*v)(p->from_object, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear__memoryviewslice(PyObject *o) { + PyObject* tmp; + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + __pyx_tp_clear_memoryview(o); + tmp = ((PyObject*)p->from_object); + p->from_object = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + __PYX_XDEC_MEMVIEW(&p->from_slice, 1); + return 0; +} + +static PyObject *__pyx_getprop___pyx_memoryviewslice_base(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_16_memoryviewslice_4base_1__get__(o); +} + +static PyMethodDef __pyx_methods__memoryviewslice[] = { + {"__reduce_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_1__reduce_cython__, METH_NOARGS, 0}, + {"__setstate_cython__", (PyCFunction)__pyx_pw___pyx_memoryviewslice_3__setstate_cython__, METH_O, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets__memoryviewslice[] = { + {(char *)"base", __pyx_getprop___pyx_memoryviewslice_base, 0, (char *)0, 0}, + {0, 0, 0, 0, 0} +}; + +static PyTypeObject __pyx_type___pyx_memoryviewslice = { + PyVarObject_HEAD_INIT(0, 0) + "zoo.board_games.tictactoe.envs.legal_actions_cython._memoryviewslice", /*tp_name*/ + sizeof(struct __pyx_memoryviewslice_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc__memoryviewslice, /*tp_dealloc*/ + #if PY_VERSION_HEX < 0x030800b4 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 + 0, /*tp_vectorcall_offset*/ + #endif + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + #if PY_MAJOR_VERSION < 3 + 0, /*tp_compare*/ + #endif + #if PY_MAJOR_VERSION >= 3 + 0, /*tp_as_async*/ + #endif + #if CYTHON_COMPILING_IN_PYPY + __pyx_memoryview___repr__, /*tp_repr*/ + #else + 0, /*tp_repr*/ + #endif + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + #if CYTHON_COMPILING_IN_PYPY + __pyx_memoryview___str__, /*tp_str*/ + #else + 0, /*tp_str*/ + #endif + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + "Internal class for passing memoryview slices to Python", /*tp_doc*/ + __pyx_tp_traverse__memoryviewslice, /*tp_traverse*/ + __pyx_tp_clear__memoryviewslice, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods__memoryviewslice, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets__memoryviewslice, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new__memoryviewslice, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if PY_VERSION_HEX >= 0x030400a1 + 0, /*tp_finalize*/ + #endif + #if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800) + 0, /*tp_vectorcall*/ + #endif + #if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000 + 0, /*tp_print*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 + 0, /*tp_pypy_flags*/ + #endif +}; + +static PyMethodDef __pyx_methods[] = { + {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_legal_actions_cython(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_legal_actions_cython}, + {0, NULL} +}; +#endif + +static struct PyModuleDef __pyx_moduledef = { + PyModuleDef_HEAD_INIT, + "legal_actions_cython", + 0, /* m_doc */ + #if CYTHON_PEP489_MULTI_PHASE_INIT + 0, /* m_size */ + #else + -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ +}; +#endif +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + +static __Pyx_StringTabEntry __pyx_string_tab[] = { + {&__pyx_n_s_ASCII, __pyx_k_ASCII, sizeof(__pyx_k_ASCII), 0, 0, 1, 1}, + {&__pyx_kp_s_Buffer_view_does_not_expose_stri, __pyx_k_Buffer_view_does_not_expose_stri, sizeof(__pyx_k_Buffer_view_does_not_expose_stri), 0, 0, 1, 0}, + {&__pyx_kp_s_Can_only_create_a_buffer_that_is, __pyx_k_Can_only_create_a_buffer_that_is, sizeof(__pyx_k_Can_only_create_a_buffer_that_is), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_assign_to_read_only_memor, __pyx_k_Cannot_assign_to_read_only_memor, sizeof(__pyx_k_Cannot_assign_to_read_only_memor), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_create_writable_memory_vi, __pyx_k_Cannot_create_writable_memory_vi, sizeof(__pyx_k_Cannot_create_writable_memory_vi), 0, 0, 1, 0}, + {&__pyx_kp_s_Cannot_index_with_type_s, __pyx_k_Cannot_index_with_type_s, sizeof(__pyx_k_Cannot_index_with_type_s), 0, 0, 1, 0}, + {&__pyx_n_s_Ellipsis, __pyx_k_Ellipsis, sizeof(__pyx_k_Ellipsis), 0, 0, 1, 1}, + {&__pyx_kp_s_Empty_shape_tuple_for_cython_arr, __pyx_k_Empty_shape_tuple_for_cython_arr, sizeof(__pyx_k_Empty_shape_tuple_for_cython_arr), 0, 0, 1, 0}, + {&__pyx_kp_s_Incompatible_checksums_0x_x_vs_0, __pyx_k_Incompatible_checksums_0x_x_vs_0, sizeof(__pyx_k_Incompatible_checksums_0x_x_vs_0), 0, 0, 1, 0}, + {&__pyx_n_s_IndexError, __pyx_k_IndexError, sizeof(__pyx_k_IndexError), 0, 0, 1, 1}, + {&__pyx_kp_s_Indirect_dimensions_not_supporte, __pyx_k_Indirect_dimensions_not_supporte, sizeof(__pyx_k_Indirect_dimensions_not_supporte), 0, 0, 1, 0}, + {&__pyx_kp_s_Invalid_mode_expected_c_or_fortr, __pyx_k_Invalid_mode_expected_c_or_fortr, sizeof(__pyx_k_Invalid_mode_expected_c_or_fortr), 0, 0, 1, 0}, + {&__pyx_kp_s_Invalid_shape_in_axis_d_d, __pyx_k_Invalid_shape_in_axis_d_d, sizeof(__pyx_k_Invalid_shape_in_axis_d_d), 0, 0, 1, 0}, + {&__pyx_n_s_MemoryError, __pyx_k_MemoryError, sizeof(__pyx_k_MemoryError), 0, 0, 1, 1}, + {&__pyx_kp_s_MemoryView_of_r_at_0x_x, __pyx_k_MemoryView_of_r_at_0x_x, sizeof(__pyx_k_MemoryView_of_r_at_0x_x), 0, 0, 1, 0}, + {&__pyx_kp_s_MemoryView_of_r_object, __pyx_k_MemoryView_of_r_object, sizeof(__pyx_k_MemoryView_of_r_object), 0, 0, 1, 0}, + {&__pyx_n_b_O, __pyx_k_O, sizeof(__pyx_k_O), 0, 0, 0, 1}, + {&__pyx_kp_s_Out_of_bounds_on_buffer_access_a, __pyx_k_Out_of_bounds_on_buffer_access_a, sizeof(__pyx_k_Out_of_bounds_on_buffer_access_a), 0, 0, 1, 0}, + {&__pyx_n_s_PickleError, __pyx_k_PickleError, sizeof(__pyx_k_PickleError), 0, 0, 1, 1}, + {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1}, + {&__pyx_kp_s_Unable_to_convert_item_to_object, __pyx_k_Unable_to_convert_item_to_object, sizeof(__pyx_k_Unable_to_convert_item_to_object), 0, 0, 1, 0}, + {&__pyx_n_s_ValueError, __pyx_k_ValueError, sizeof(__pyx_k_ValueError), 0, 0, 1, 1}, + {&__pyx_n_s_View_MemoryView, __pyx_k_View_MemoryView, sizeof(__pyx_k_View_MemoryView), 0, 0, 1, 1}, + {&__pyx_n_s_allocate_buffer, __pyx_k_allocate_buffer, sizeof(__pyx_k_allocate_buffer), 0, 0, 1, 1}, + {&__pyx_n_s_base, __pyx_k_base, sizeof(__pyx_k_base), 0, 0, 1, 1}, + {&__pyx_n_s_board, __pyx_k_board, sizeof(__pyx_k_board), 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_i, __pyx_k_i, sizeof(__pyx_k_i), 0, 0, 1, 1}, + {&__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_j, __pyx_k_j, sizeof(__pyx_k_j), 0, 0, 1, 1}, + {&__pyx_n_s_legal_actions, __pyx_k_legal_actions, sizeof(__pyx_k_legal_actions), 0, 0, 1, 1}, + {&__pyx_n_s_legal_actions_cython, __pyx_k_legal_actions_cython, sizeof(__pyx_k_legal_actions_cython), 0, 0, 1, 1}, + {&__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_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_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_kp_s_zoo_board_games_tictactoe_envs_l, __pyx_k_zoo_board_games_tictactoe_envs_l, sizeof(__pyx_k_zoo_board_games_tictactoe_envs_l), 0, 0, 1, 0}, + {&__pyx_n_s_zoo_board_games_tictactoe_envs_l_2, __pyx_k_zoo_board_games_tictactoe_envs_l_2, sizeof(__pyx_k_zoo_board_games_tictactoe_envs_l_2), 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, 12, __pyx_L1_error) + __pyx_builtin_ValueError = __Pyx_GetBuiltinName(__pyx_n_s_ValueError); if (!__pyx_builtin_ValueError) __PYX_ERR(1, 134, __pyx_L1_error) + __pyx_builtin_MemoryError = __Pyx_GetBuiltinName(__pyx_n_s_MemoryError); if (!__pyx_builtin_MemoryError) __PYX_ERR(1, 149, __pyx_L1_error) + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_n_s_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 152, __pyx_L1_error) + __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(1, 2, __pyx_L1_error) + __pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_n_s_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(1, 406, __pyx_L1_error) + __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_n_s_id); if (!__pyx_builtin_id) __PYX_ERR(1, 615, __pyx_L1_error) + __pyx_builtin_IndexError = __Pyx_GetBuiltinName(__pyx_n_s_IndexError); if (!__pyx_builtin_IndexError) __PYX_ERR(1, 834, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "View.MemoryView":134 + * + * if not self.ndim: + * raise ValueError("Empty shape tuple for cython.array") # <<<<<<<<<<<<<< + * + * if itemsize <= 0: + */ + __pyx_tuple_ = PyTuple_Pack(1, __pyx_kp_s_Empty_shape_tuple_for_cython_arr); if (unlikely(!__pyx_tuple_)) __PYX_ERR(1, 134, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple_); + __Pyx_GIVEREF(__pyx_tuple_); + + /* "View.MemoryView":137 + * + * if itemsize <= 0: + * raise ValueError("itemsize <= 0 for cython.array") # <<<<<<<<<<<<<< + * + * if not isinstance(format, bytes): + */ + __pyx_tuple__2 = PyTuple_Pack(1, __pyx_kp_s_itemsize_0_for_cython_array); if (unlikely(!__pyx_tuple__2)) __PYX_ERR(1, 137, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__2); + __Pyx_GIVEREF(__pyx_tuple__2); + + /* "View.MemoryView":149 + * + * if not self._shape: + * raise MemoryError("unable to allocate shape and strides.") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_shape_and_str); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(1, 149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__3); + __Pyx_GIVEREF(__pyx_tuple__3); + + /* "View.MemoryView":177 + * self.data = malloc(self.len) + * if not self.data: + * raise MemoryError("unable to allocate array data.") # <<<<<<<<<<<<<< + * + * if self.dtype_is_object: + */ + __pyx_tuple__4 = PyTuple_Pack(1, __pyx_kp_s_unable_to_allocate_array_data); if (unlikely(!__pyx_tuple__4)) __PYX_ERR(1, 177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__4); + __Pyx_GIVEREF(__pyx_tuple__4); + + /* "View.MemoryView":193 + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + * raise ValueError("Can only create a buffer that is contiguous in memory.") # <<<<<<<<<<<<<< + * info.buf = self.data + * info.len = self.len + */ + __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s_Can_only_create_a_buffer_that_is); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(1, 193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__5); + __Pyx_GIVEREF(__pyx_tuple__5); + + /* "(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__6 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__6); + __Pyx_GIVEREF(__pyx_tuple__6); + + /* "(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__7 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__7); + __Pyx_GIVEREF(__pyx_tuple__7); + + /* "View.MemoryView":420 + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: + * raise TypeError("Cannot assign to read-only memoryview") # <<<<<<<<<<<<<< + * + * have_slices, index = _unellipsify(index, self.view.ndim) + */ + __pyx_tuple__8 = PyTuple_Pack(1, __pyx_kp_s_Cannot_assign_to_read_only_memor); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(1, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__8); + __Pyx_GIVEREF(__pyx_tuple__8); + + /* "View.MemoryView":497 + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + * raise ValueError("Unable to convert item to object") # <<<<<<<<<<<<<< + * else: + * if len(self.view.format) == 1: + */ + __pyx_tuple__9 = PyTuple_Pack(1, __pyx_kp_s_Unable_to_convert_item_to_object); if (unlikely(!__pyx_tuple__9)) __PYX_ERR(1, 497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__9); + __Pyx_GIVEREF(__pyx_tuple__9); + + /* "View.MemoryView":522 + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError("Cannot create writable memory view from read-only memoryview") # <<<<<<<<<<<<<< + * + * if flags & PyBUF_ND: + */ + __pyx_tuple__10 = PyTuple_Pack(1, __pyx_kp_s_Cannot_create_writable_memory_vi); if (unlikely(!__pyx_tuple__10)) __PYX_ERR(1, 522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__10); + __Pyx_GIVEREF(__pyx_tuple__10); + + /* "View.MemoryView":572 + * if self.view.strides == NULL: + * + * raise ValueError("Buffer view does not expose strides") # <<<<<<<<<<<<<< + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) + */ + __pyx_tuple__11 = PyTuple_Pack(1, __pyx_kp_s_Buffer_view_does_not_expose_stri); if (unlikely(!__pyx_tuple__11)) __PYX_ERR(1, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__11); + __Pyx_GIVEREF(__pyx_tuple__11); + + /* "View.MemoryView":579 + * def suboffsets(self): + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) + */ + __pyx_tuple__12 = PyTuple_New(1); if (unlikely(!__pyx_tuple__12)) __PYX_ERR(1, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__12); + __Pyx_INCREF(__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_int_neg_1); + PyTuple_SET_ITEM(__pyx_tuple__12, 0, __pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_tuple__12); + + /* "(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__13 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__13)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__13); + __Pyx_GIVEREF(__pyx_tuple__13); + + /* "(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__14 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__14)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__14); + __Pyx_GIVEREF(__pyx_tuple__14); + + /* "View.MemoryView":684 + * if item is Ellipsis: + * if not seen_ellipsis: + * result.extend([slice(None)] * (ndim - len(tup) + 1)) # <<<<<<<<<<<<<< + * seen_ellipsis = True + * else: + */ + __pyx_slice__15 = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_slice__15)) __PYX_ERR(1, 684, __pyx_L1_error) + __Pyx_GOTREF(__pyx_slice__15); + __Pyx_GIVEREF(__pyx_slice__15); + + /* "View.MemoryView":705 + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + * raise ValueError("Indirect dimensions not supported") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__16 = PyTuple_Pack(1, __pyx_kp_s_Indirect_dimensions_not_supporte); if (unlikely(!__pyx_tuple__16)) __PYX_ERR(1, 705, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__16); + __Pyx_GIVEREF(__pyx_tuple__16); + + /* "(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__17 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__17)) __PYX_ERR(1, 2, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__17); + __Pyx_GIVEREF(__pyx_tuple__17); + + /* "(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__18 = PyTuple_Pack(1, __pyx_kp_s_no_default___reduce___due_to_non); if (unlikely(!__pyx_tuple__18)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__18); + __Pyx_GIVEREF(__pyx_tuple__18); + __pyx_tuple__19 = PyTuple_Pack(3, __pyx_int_184977713, __pyx_int_136983863, __pyx_int_112105877); if (unlikely(!__pyx_tuple__19)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__19); + __Pyx_GIVEREF(__pyx_tuple__19); + + /* "zoo/board_games/tictactoe/envs/legal_actions_cython.pyx":6 + * @cython.boundscheck(False) # Disable bounds checking for performance + * @cython.wraparound(False) # Disable negative indexing for performance + * def legal_actions_cython(int32_t[:, :] board): # <<<<<<<<<<<<<< + * # Use a Python list to store possible legal actions + * cdef list legal_actions = [] + */ + __pyx_tuple__20 = PyTuple_Pack(5, __pyx_n_s_board, __pyx_n_s_board, __pyx_n_s_legal_actions, __pyx_n_s_i, __pyx_n_s_j); if (unlikely(!__pyx_tuple__20)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__20); + __Pyx_GIVEREF(__pyx_tuple__20); + __pyx_codeobj__21 = (PyObject*)__Pyx_PyCode_New(1, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__20, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_zoo_board_games_tictactoe_envs_l, __pyx_n_s_legal_actions_cython, 6, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__21)) __PYX_ERR(0, 6, __pyx_L1_error) + + /* "View.MemoryView":287 + * return self.name + * + * cdef generic = Enum("") # <<<<<<<<<<<<<< + * cdef strided = Enum("") # default + * cdef indirect = Enum("") + */ + __pyx_tuple__22 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct_or_indirect); if (unlikely(!__pyx_tuple__22)) __PYX_ERR(1, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__22); + __Pyx_GIVEREF(__pyx_tuple__22); + + /* "View.MemoryView":288 + * + * cdef generic = Enum("") + * cdef strided = Enum("") # default # <<<<<<<<<<<<<< + * cdef indirect = Enum("") + * + */ + __pyx_tuple__23 = PyTuple_Pack(1, __pyx_kp_s_strided_and_direct); if (unlikely(!__pyx_tuple__23)) __PYX_ERR(1, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__23); + __Pyx_GIVEREF(__pyx_tuple__23); + + /* "View.MemoryView":289 + * cdef generic = Enum("") + * cdef strided = Enum("") # default + * cdef indirect = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__24 = PyTuple_Pack(1, __pyx_kp_s_strided_and_indirect); if (unlikely(!__pyx_tuple__24)) __PYX_ERR(1, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__24); + __Pyx_GIVEREF(__pyx_tuple__24); + + /* "View.MemoryView":292 + * + * + * cdef contiguous = Enum("") # <<<<<<<<<<<<<< + * cdef indirect_contiguous = Enum("") + * + */ + __pyx_tuple__25 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_direct); if (unlikely(!__pyx_tuple__25)) __PYX_ERR(1, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__25); + __Pyx_GIVEREF(__pyx_tuple__25); + + /* "View.MemoryView":293 + * + * cdef contiguous = Enum("") + * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_tuple__26 = PyTuple_Pack(1, __pyx_kp_s_contiguous_and_indirect); if (unlikely(!__pyx_tuple__26)) __PYX_ERR(1, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__26); + __Pyx_GIVEREF(__pyx_tuple__26); + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + __pyx_tuple__27 = 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__27)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_tuple__27); + __Pyx_GIVEREF(__pyx_tuple__27); + __pyx_codeobj__28 = (PyObject*)__Pyx_PyCode_New(3, 0, 5, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__27, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_stringsource, __pyx_n_s_pyx_unpickle_Enum, 1, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__28)) __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) { + if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_0 = PyInt_FromLong(0); if (unlikely(!__pyx_int_0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_112105877 = PyInt_FromLong(112105877L); if (unlikely(!__pyx_int_112105877)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_136983863 = PyInt_FromLong(136983863L); if (unlikely(!__pyx_int_136983863)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_184977713 = PyInt_FromLong(184977713L); if (unlikely(!__pyx_int_184977713)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_int_neg_1 = PyInt_FromLong(-1); if (unlikely(!__pyx_int_neg_1)) __PYX_ERR(0, 1, __pyx_L1_error) + return 0; + __pyx_L1_error:; + return -1; +} + +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(void); /*proto*/ + +static int __Pyx_modinit_global_init_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + generic = Py_None; Py_INCREF(Py_None); + strided = Py_None; Py_INCREF(Py_None); + indirect = Py_None; Py_INCREF(Py_None); + contiguous = Py_None; Py_INCREF(Py_None); + indirect_contiguous = Py_None; Py_INCREF(Py_None); + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(void) { + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + __pyx_vtabptr_array = &__pyx_vtable_array; + __pyx_vtable_array.get_memview = (PyObject *(*)(struct __pyx_array_obj *))__pyx_array_get_memview; + if (PyType_Ready(&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_array.tp_print = 0; + #endif + if (__Pyx_SetVtable(__pyx_type___pyx_array.tp_dict, __pyx_vtabptr_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_array) < 0) __PYX_ERR(1, 106, __pyx_L1_error) + __pyx_array_type = &__pyx_type___pyx_array; + if (PyType_Ready(&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 280, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_MemviewEnum.tp_print = 0; + #endif + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_MemviewEnum.tp_dictoffset && __pyx_type___pyx_MemviewEnum.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type___pyx_MemviewEnum.tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_MemviewEnum) < 0) __PYX_ERR(1, 280, __pyx_L1_error) + __pyx_MemviewEnum_type = &__pyx_type___pyx_MemviewEnum; + __pyx_vtabptr_memoryview = &__pyx_vtable_memoryview; + __pyx_vtable_memoryview.get_item_pointer = (char *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_get_item_pointer; + __pyx_vtable_memoryview.is_slice = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_is_slice; + __pyx_vtable_memoryview.setitem_slice_assignment = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_slice_assignment; + __pyx_vtable_memoryview.setitem_slice_assign_scalar = (PyObject *(*)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_setitem_slice_assign_scalar; + __pyx_vtable_memoryview.setitem_indexed = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_indexed; + __pyx_vtable_memoryview.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryview_convert_item_to_object; + __pyx_vtable_memoryview.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryview_assign_item_from_object; + if (PyType_Ready(&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_memoryview.tp_print = 0; + #endif + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryview.tp_dictoffset && __pyx_type___pyx_memoryview.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type___pyx_memoryview.tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + if (__Pyx_SetVtable(__pyx_type___pyx_memoryview.tp_dict, __pyx_vtabptr_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryview) < 0) __PYX_ERR(1, 331, __pyx_L1_error) + __pyx_memoryview_type = &__pyx_type___pyx_memoryview; + __pyx_vtabptr__memoryviewslice = &__pyx_vtable__memoryviewslice; + __pyx_vtable__memoryviewslice.__pyx_base = *__pyx_vtabptr_memoryview; + __pyx_vtable__memoryviewslice.__pyx_base.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryviewslice_convert_item_to_object; + __pyx_vtable__memoryviewslice.__pyx_base.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryviewslice_assign_item_from_object; + __pyx_type___pyx_memoryviewslice.tp_base = __pyx_memoryview_type; + if (PyType_Ready(&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) + #if PY_VERSION_HEX < 0x030800B1 + __pyx_type___pyx_memoryviewslice.tp_print = 0; + #endif + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_type___pyx_memoryviewslice.tp_dictoffset && __pyx_type___pyx_memoryviewslice.tp_getattro == PyObject_GenericGetAttr)) { + __pyx_type___pyx_memoryviewslice.tp_getattro = __Pyx_PyObject_GenericGetAttr; + } + if (__Pyx_SetVtable(__pyx_type___pyx_memoryviewslice.tp_dict, __pyx_vtabptr__memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject*)&__pyx_type___pyx_memoryviewslice) < 0) __PYX_ERR(1, 967, __pyx_L1_error) + __pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(void) { + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + + +#ifndef CYTHON_NO_PYINIT_EXPORT +#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#elif PY_MAJOR_VERSION < 3 +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" void +#else +#define __Pyx_PyMODINIT_FUNC void +#endif +#else +#ifdef __cplusplus +#define __Pyx_PyMODINIT_FUNC extern "C" PyObject * +#else +#define __Pyx_PyMODINIT_FUNC PyObject * +#endif +#endif + + +#if PY_MAJOR_VERSION < 3 +__Pyx_PyMODINIT_FUNC initlegal_actions_cython(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC initlegal_actions_cython(void) +#else +__Pyx_PyMODINIT_FUNC PyInit_legal_actions_cython(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_legal_actions_cython(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_legal_actions_cython(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 'legal_actions_cython' 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_legal_actions_cython(void)", 0); + if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pxy_PyFrame_Initialize_Offsets + __Pxy_PyFrame_Initialize_Offsets(); + #endif + __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + #ifdef __Pyx_CyFunction_USED + if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_FusedFunction_USED + if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Coroutine_USED + if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_Generator_USED + if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #ifdef __Pyx_StopAsyncIteration_USED + if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + /*--- Library function declarations ---*/ + /*--- Threads initialization code ---*/ + #if defined(WITH_THREAD) && PY_VERSION_HEX < 0x030700F0 && defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS + PyEval_InitThreads(); + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_m = __pyx_pyinit_module; + Py_INCREF(__pyx_m); + #else + #if PY_MAJOR_VERSION < 3 + __pyx_m = Py_InitModule4("legal_actions_cython", __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_zoo__board_games__tictactoe__envs__legal_actions_cython) { + 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, "zoo.board_games.tictactoe.envs.legal_actions_cython")) { + if (unlikely(PyDict_SetItemString(modules, "zoo.board_games.tictactoe.envs.legal_actions_cython", __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 + + /* "zoo/board_games/tictactoe/envs/legal_actions_cython.pyx":6 + * @cython.boundscheck(False) # Disable bounds checking for performance + * @cython.wraparound(False) # Disable negative indexing for performance + * def legal_actions_cython(int32_t[:, :] board): # <<<<<<<<<<<<<< + * # Use a Python list to store possible legal actions + * cdef list legal_actions = [] + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_3zoo_11board_games_9tictactoe_4envs_20legal_actions_cython_1legal_actions_cython, NULL, __pyx_n_s_zoo_board_games_tictactoe_envs_l_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_legal_actions_cython, __pyx_t_1) < 0) __PYX_ERR(0, 6, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "zoo/board_games/tictactoe/envs/legal_actions_cython.pyx":1 + * from libc.stdint cimport int32_t # <<<<<<<<<<<<<< + * import cython + * + */ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_1) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":210 + * info.obj = self + * + * __pyx_getbuffer = capsule( &__pyx_array_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * def __dealloc__(array self): + */ + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_array_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_array_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 210, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_array_type); + + /* "View.MemoryView":287 + * return self.name + * + * cdef generic = Enum("") # <<<<<<<<<<<<<< + * cdef strided = Enum("") # default + * cdef indirect = Enum("") + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__22, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 287, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(generic); + __Pyx_DECREF_SET(generic, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":288 + * + * cdef generic = Enum("") + * cdef strided = Enum("") # default # <<<<<<<<<<<<<< + * cdef indirect = Enum("") + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__23, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(strided); + __Pyx_DECREF_SET(strided, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":289 + * cdef generic = Enum("") + * cdef strided = Enum("") # default + * cdef indirect = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__24, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(indirect); + __Pyx_DECREF_SET(indirect, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":292 + * + * + * cdef contiguous = Enum("") # <<<<<<<<<<<<<< + * cdef indirect_contiguous = Enum("") + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__25, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 292, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(contiguous); + __Pyx_DECREF_SET(contiguous, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":293 + * + * cdef contiguous = Enum("") + * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __Pyx_PyObject_Call(((PyObject *)__pyx_MemviewEnum_type), __pyx_tuple__26, NULL); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 293, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XGOTREF(indirect_contiguous); + __Pyx_DECREF_SET(indirect_contiguous, __pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":317 + * + * DEF THREAD_LOCKS_PREALLOCATED = 8 + * cdef int __pyx_memoryview_thread_locks_used = 0 # <<<<<<<<<<<<<< + * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ + * PyThread_allocate_lock(), + */ + __pyx_memoryview_thread_locks_used = 0; + + /* "View.MemoryView":318 + * DEF THREAD_LOCKS_PREALLOCATED = 8 + * cdef int __pyx_memoryview_thread_locks_used = 0 + * cdef PyThread_type_lock[THREAD_LOCKS_PREALLOCATED] __pyx_memoryview_thread_locks = [ # <<<<<<<<<<<<<< + * PyThread_allocate_lock(), + * PyThread_allocate_lock(), + */ + __pyx_t_2[0] = PyThread_allocate_lock(); + __pyx_t_2[1] = PyThread_allocate_lock(); + __pyx_t_2[2] = PyThread_allocate_lock(); + __pyx_t_2[3] = PyThread_allocate_lock(); + __pyx_t_2[4] = PyThread_allocate_lock(); + __pyx_t_2[5] = PyThread_allocate_lock(); + __pyx_t_2[6] = PyThread_allocate_lock(); + __pyx_t_2[7] = PyThread_allocate_lock(); + memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_2, sizeof(__pyx_memoryview_thread_locks[0]) * (8)); + + /* "View.MemoryView":551 + * info.obj = self + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 551, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_memoryview_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 551, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_memoryview_type); + + /* "View.MemoryView":997 + * return self.from_object + * + * __pyx_getbuffer = capsule( &__pyx_memoryview_getbuffer, "getbuffer(obj, view, flags)") # <<<<<<<<<<<<<< + * + * + */ + __pyx_t_1 = __pyx_capsule_create(((void *)(&__pyx_memoryview_getbuffer)), ((char *)"getbuffer(obj, view, flags)")); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 997, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem((PyObject *)__pyx_memoryviewslice_type->tp_dict, __pyx_n_s_pyx_getbuffer, __pyx_t_1) < 0) __PYX_ERR(1, 997, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + PyType_Modified(__pyx_memoryviewslice_type); + + /* "(tree fragment)":1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_PickleError + * cdef object __pyx_result + */ + __pyx_t_1 = PyCFunction_NewEx(&__pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum, NULL, __pyx_n_s_View_MemoryView); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_d, __pyx_n_s_pyx_unpickle_Enum, __pyx_t_1) < 0) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, tuple __pyx_state): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * if len(__pyx_state) > 1 and hasattr(__pyx_result, '__dict__'): + */ + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + if (__pyx_m) { + if (__pyx_d) { + __Pyx_AddTraceback("init zoo.board_games.tictactoe.envs.legal_actions_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + Py_CLEAR(__pyx_m); + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init zoo.board_games.tictactoe.envs.legal_actions_cython"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #elif PY_MAJOR_VERSION >= 3 + return __pyx_m; + #else + return; + #endif +} + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* PyObjectGetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); +#if PY_MAJOR_VERSION < 3 + if (likely(tp->tp_getattr)) + return tp->tp_getattr(obj, PyString_AS_STRING(attr_name)); +#endif + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name); + if (unlikely(!result)) { + PyErr_Format(PyExc_NameError, +#if PY_MAJOR_VERSION >= 3 + "name '%U' is not defined", name); +#else + "name '%.200s' is not defined", PyString_AS_STRING(name)); +#endif + } + return result; +} + +/* MemviewSliceInit */ +static int +__Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview, + int ndim, + __Pyx_memviewslice *memviewslice, + int memview_is_new_reference) +{ + __Pyx_RefNannyDeclarations + int i, retval=-1; + Py_buffer *buf = &memview->view; + __Pyx_RefNannySetupContext("init_memviewslice", 0); + if (unlikely(memviewslice->memview || memviewslice->data)) { + PyErr_SetString(PyExc_ValueError, + "memviewslice is already initialized!"); + goto fail; + } + if (buf->strides) { + for (i = 0; i < ndim; i++) { + memviewslice->strides[i] = buf->strides[i]; + } + } else { + Py_ssize_t stride = buf->itemsize; + for (i = ndim - 1; i >= 0; i--) { + memviewslice->strides[i] = stride; + stride *= buf->shape[i]; + } + } + for (i = 0; i < ndim; i++) { + memviewslice->shape[i] = buf->shape[i]; + if (buf->suboffsets) { + memviewslice->suboffsets[i] = buf->suboffsets[i]; + } else { + memviewslice->suboffsets[i] = -1; + } + } + memviewslice->memview = memview; + memviewslice->data = (char *)buf->buf; + if (__pyx_add_acquisition_count(memview) == 0 && !memview_is_new_reference) { + Py_INCREF(memview); + } + retval = 0; + goto no_fail; +fail: + memviewslice->memview = 0; + memviewslice->data = 0; + retval = -1; +no_fail: + __Pyx_RefNannyFinishContext(); + return retval; +} +#ifndef Py_NO_RETURN +#define Py_NO_RETURN +#endif +static void __pyx_fatalerror(const char *fmt, ...) Py_NO_RETURN { + va_list vargs; + char msg[200]; +#if PY_VERSION_HEX >= 0x030A0000 || defined(HAVE_STDARG_PROTOTYPES) + va_start(vargs, fmt); +#else + va_start(vargs); +#endif + vsnprintf(msg, 200, fmt, vargs); + va_end(vargs); + Py_FatalError(msg); +} +static CYTHON_INLINE int +__pyx_add_acquisition_count_locked(__pyx_atomic_int *acquisition_count, + PyThread_type_lock lock) +{ + int result; + PyThread_acquire_lock(lock, 1); + result = (*acquisition_count)++; + PyThread_release_lock(lock); + return result; +} +static CYTHON_INLINE int +__pyx_sub_acquisition_count_locked(__pyx_atomic_int *acquisition_count, + PyThread_type_lock lock) +{ + int result; + PyThread_acquire_lock(lock, 1); + result = (*acquisition_count)--; + PyThread_release_lock(lock); + return result; +} +static CYTHON_INLINE void +__Pyx_INC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno) +{ + int first_time; + struct __pyx_memoryview_obj *memview = memslice->memview; + if (unlikely(!memview || (PyObject *) memview == Py_None)) + return; + if (unlikely(__pyx_get_slice_count(memview) < 0)) + __pyx_fatalerror("Acquisition count is %d (line %d)", + __pyx_get_slice_count(memview), lineno); + first_time = __pyx_add_acquisition_count(memview) == 0; + if (unlikely(first_time)) { + if (have_gil) { + Py_INCREF((PyObject *) memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_INCREF((PyObject *) memview); + PyGILState_Release(_gilstate); + } + } +} +static CYTHON_INLINE void __Pyx_XDEC_MEMVIEW(__Pyx_memviewslice *memslice, + int have_gil, int lineno) { + int last_time; + struct __pyx_memoryview_obj *memview = memslice->memview; + if (unlikely(!memview || (PyObject *) memview == Py_None)) { + memslice->memview = NULL; + return; + } + if (unlikely(__pyx_get_slice_count(memview) <= 0)) + __pyx_fatalerror("Acquisition count is %d (line %d)", + __pyx_get_slice_count(memview), lineno); + last_time = __pyx_sub_acquisition_count(memview) == 1; + memslice->data = NULL; + if (unlikely(last_time)) { + if (have_gil) { + Py_CLEAR(memslice->memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_CLEAR(memslice->memview); + PyGILState_Release(_gilstate); + } + } else { + memslice->memview = NULL; + } +} + +/* RaiseArgTupleInvalid */ +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* RaiseDoubleKeywords */ +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION >= 3 + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); + #else + "%s() got multiple values for keyword argument '%s'", func_name, + PyString_AsString(kw_name)); + #endif +} + +/* ParseKeywords */ +static int __Pyx_ParseOptionalKeywords( + PyObject *kwds, + PyObject **argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject *key = 0, *value = 0; + Py_ssize_t pos = 0; + PyObject*** name; + PyObject*** first_kw_arg = argnames + num_pos_args; + while (PyDict_Next(kwds, &pos, &key, &value)) { + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + values[name-argnames] = value; + continue; + } + name = first_kw_arg; + #if PY_MAJOR_VERSION < 3 + if (likely(PyString_Check(key))) { + while (*name) { + if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key)) + && _PyString_Eq(**name, key)) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + if ((**argname == key) || ( + (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key)) + && _PyString_Eq(**argname, key))) { + goto arg_passed_twice; + } + argname++; + } + } + } else + #endif + if (likely(PyUnicode_Check(key))) { + while (*name) { + int cmp = (**name == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**name) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**name, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + values[name-argnames] = value; + break; + } + name++; + } + if (*name) continue; + else { + PyObject*** argname = argnames; + while (argname != first_kw_arg) { + int cmp = (**argname == key) ? 0 : + #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3 + (__Pyx_PyUnicode_GET_LENGTH(**argname) != __Pyx_PyUnicode_GET_LENGTH(key)) ? 1 : + #endif + PyUnicode_Compare(**argname, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + argname++; + } + } + } else + goto invalid_keyword_type; + if (kwds2) { + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else { + goto invalid_keyword; + } + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + #if PY_MAJOR_VERSION < 3 + "%.200s() got an unexpected keyword argument '%.200s'", + function_name, PyString_AsString(key)); + #else + "%s() got an unexpected keyword argument '%U'", + function_name, key); + #endif +bad: + return -1; +} + +/* ArgTypeTest */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (exact) { + #if PY_MAJOR_VERSION == 2 + if ((type == &PyBaseString_Type) && likely(__Pyx_PyBaseString_CheckExact(obj))) return 1; + #endif + } + else { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got %.200s)", + name, type->tp_name, Py_TYPE(obj)->tp_name); + return 0; +} + +/* PyObjectCall */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *result; + ternaryfunc call = Py_TYPE(func)->tp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +} +#endif + +/* RaiseException */ +#if PY_MAJOR_VERSION < 3 +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, + CYTHON_UNUSED PyObject *cause) { + __Pyx_PyThreadState_declare + Py_XINCREF(type); + if (!value || value == Py_None) + value = NULL; + else + Py_INCREF(value); + if (!tb || tb == Py_None) + tb = NULL; + else { + Py_INCREF(tb); + if (!PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto raise_error; + } + } + if (PyType_Check(type)) { +#if CYTHON_COMPILING_IN_PYPY + if (!value) { + Py_INCREF(Py_None); + value = Py_None; + } +#endif + PyErr_NormalizeException(&type, &value, &tb); + } else { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto raise_error; + } + value = type; + type = (PyObject*) Py_TYPE(type); + Py_INCREF(type); + if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto raise_error; + } + } + __Pyx_PyThreadState_assign + __Pyx_ErrRestore(type, value, tb); + return; +raise_error: + Py_XDECREF(value); + Py_XDECREF(type); + Py_XDECREF(tb); + return; +} +#else +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if CYTHON_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 + +/* PyCFunctionFastCall */ +#if CYTHON_FAST_PYCCALL +static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) { + PyCFunctionObject *func = (PyCFunctionObject*)func_obj; + PyCFunction meth = PyCFunction_GET_FUNCTION(func); + PyObject *self = PyCFunction_GET_SELF(func); + int flags = PyCFunction_GET_FLAGS(func); + assert(PyCFunction_Check(func)); + assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS | METH_STACKLESS))); + assert(nargs >= 0); + assert(nargs == 0 || args != NULL); + /* _PyCFunction_FastCallDict() must not be called with an exception set, + because it may clear it (directly or indirectly) and so the + caller loses its exception */ + assert(!PyErr_Occurred()); + if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) { + return (*((__Pyx_PyCFunctionFastWithKeywords)(void*)meth)) (self, args, nargs, NULL); + } else { + return (*((__Pyx_PyCFunctionFast)(void*)meth)) (self, args, nargs); + } +} +#endif + +/* PyFunctionFastCall */ +#if CYTHON_FAST_PYCALL +static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na, + PyObject *globals) { + PyFrameObject *f; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject **fastlocals; + Py_ssize_t i; + PyObject *result; + assert(globals != NULL); + /* XXX Perhaps we should create a specialized + PyFrame_New() that doesn't take locals, but does + take builtins without sanity checking them. + */ + assert(tstate != NULL); + f = PyFrame_New(tstate, co, globals, NULL); + if (f == NULL) { + return NULL; + } + fastlocals = __Pyx_PyFrame_GetLocalsplus(f); + for (i = 0; i < na; i++) { + Py_INCREF(*args); + fastlocals[i] = *args++; + } + result = PyEval_EvalFrameEx(f,0); + ++tstate->recursion_depth; + Py_DECREF(f); + --tstate->recursion_depth; + return result; +} +#if 1 || PY_VERSION_HEX < 0x030600B1 +static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs, PyObject *kwargs) { + PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func); + PyObject *globals = PyFunction_GET_GLOBALS(func); + PyObject *argdefs = PyFunction_GET_DEFAULTS(func); + PyObject *closure; +#if PY_MAJOR_VERSION >= 3 + PyObject *kwdefs; +#endif + PyObject *kwtuple, **k; + PyObject **d; + Py_ssize_t nd; + Py_ssize_t nk; + PyObject *result; + assert(kwargs == NULL || PyDict_Check(kwargs)); + nk = kwargs ? PyDict_Size(kwargs) : 0; + if (Py_EnterRecursiveCall((char*)" while calling a Python object")) { + return NULL; + } + if ( +#if PY_MAJOR_VERSION >= 3 + co->co_kwonlyargcount == 0 && +#endif + likely(kwargs == NULL || nk == 0) && + co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) { + if (argdefs == NULL && co->co_argcount == nargs) { + result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals); + goto done; + } + else if (nargs == 0 && argdefs != NULL + && co->co_argcount == Py_SIZE(argdefs)) { + /* function called with no arguments, but all parameters have + a default value: use default values as arguments .*/ + args = &PyTuple_GET_ITEM(argdefs, 0); + result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals); + goto done; + } + } + if (kwargs != NULL) { + Py_ssize_t pos, i; + kwtuple = PyTuple_New(2 * nk); + if (kwtuple == NULL) { + result = NULL; + goto done; + } + k = &PyTuple_GET_ITEM(kwtuple, 0); + pos = i = 0; + while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) { + Py_INCREF(k[i]); + Py_INCREF(k[i+1]); + i += 2; + } + nk = i / 2; + } + else { + kwtuple = NULL; + k = NULL; + } + closure = PyFunction_GET_CLOSURE(func); +#if PY_MAJOR_VERSION >= 3 + kwdefs = PyFunction_GET_KW_DEFAULTS(func); +#endif + if (argdefs != NULL) { + d = &PyTuple_GET_ITEM(argdefs, 0); + nd = Py_SIZE(argdefs); + } + else { + d = NULL; + nd = 0; + } +#if PY_MAJOR_VERSION >= 3 + result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, kwdefs, closure); +#else + result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL, + args, (int)nargs, + k, (int)nk, + d, (int)nd, closure); +#endif + Py_XDECREF(kwtuple); +done: + Py_LeaveRecursiveCall(); + return result; +} +#endif +#endif + +/* PyObjectCall2Args */ +static CYTHON_UNUSED PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { + PyObject *args, *result = NULL; + #if CYTHON_FAST_PYCALL + if (PyFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyFunction_FastCall(function, args, 2); + } + #endif + #if CYTHON_FAST_PYCCALL + if (__Pyx_PyFastCFunction_Check(function)) { + PyObject *args[2] = {arg1, arg2}; + return __Pyx_PyCFunction_FastCall(function, args, 2); + } + #endif + args = PyTuple_New(2); + if (unlikely(!args)) goto done; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + Py_INCREF(function); + result = __Pyx_PyObject_Call(function, args, NULL); + Py_DECREF(args); + Py_DECREF(function); +done: + return result; +} + +/* PyObjectCallMethO */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = PyCFunction_GET_FUNCTION(func); + self = PyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallOneArg */ +#if CYTHON_COMPILING_IN_CPYTHON +static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_New(1); + if (unlikely(!args)) return NULL; + Py_INCREF(arg); + PyTuple_SET_ITEM(args, 0, arg); + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { +#if CYTHON_FAST_PYCALL + if (PyFunction_Check(func)) { + return __Pyx_PyFunction_FastCall(func, &arg, 1); + } +#endif + if (likely(PyCFunction_Check(func))) { + if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) { + return __Pyx_PyObject_CallMethO(func, arg); +#if CYTHON_FAST_PYCCALL + } else if (__Pyx_PyFastCFunction_Check(func)) { + return __Pyx_PyCFunction_FastCall(func, &arg, 1); +#endif + } + } + return __Pyx__PyObject_CallOneArg(func, arg); +} +#else +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *result; + PyObject *args = PyTuple_Pack(1, arg); + if (unlikely(!args)) return NULL; + result = __Pyx_PyObject_Call(func, args, NULL); + Py_DECREF(args); + return result; +} +#endif + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY + return PyObject_RichCompareBool(s1, s2, equals); +#else +#if PY_MAJOR_VERSION < 3 + PyObject* owned_ref = NULL; +#endif + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); +#if PY_MAJOR_VERSION < 3 + if ((s1_is_unicode & (!s2_is_unicode)) && PyString_CheckExact(s2)) { + owned_ref = PyUnicode_FromObject(s2); + if (unlikely(!owned_ref)) + return -1; + s2 = owned_ref; + s2_is_unicode = 1; + } else if ((s2_is_unicode & (!s1_is_unicode)) && PyString_CheckExact(s1)) { + owned_ref = PyUnicode_FromObject(s1); + if (unlikely(!owned_ref)) + return -1; + s1 = owned_ref; + s1_is_unicode = 1; + } else if (((!s2_is_unicode) & (!s1_is_unicode))) { + return __Pyx_PyBytes_Equals(s1, s2, equals); + } +#endif + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length; + int kind; + void *data1, *data2; + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + length = __Pyx_PyUnicode_GET_LENGTH(s1); + if (length != __Pyx_PyUnicode_GET_LENGTH(s2)) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + #if CYTHON_PEP393_ENABLED + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + #else + hash1 = ((PyUnicodeObject*)s1)->hash; + hash2 = ((PyUnicodeObject*)s2)->hash; + #endif + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_EQ); +return_ne: + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(owned_ref); + #endif + return (equals == Py_NE); +#endif +} + +/* DivInt[Py_ssize_t] */ +static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t a, Py_ssize_t b) { + Py_ssize_t q = a / b; + Py_ssize_t r = a - q*b; + q -= ((r != 0) & ((r ^ b) < 0)); + return q; +} + +/* GetAttr */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { +#if CYTHON_USE_TYPE_SLOTS +#if PY_MAJOR_VERSION >= 3 + if (likely(PyUnicode_Check(n))) +#else + if (likely(PyString_Check(n))) +#endif + return __Pyx_PyObject_GetAttrStr(o, n); +#endif + return PyObject_GetAttr(o, n); +} + +/* GetItemInt */ +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (!j) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { + PyObject *r = PyList_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, wrapped_i); + Py_INCREF(r); + return r; + } + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +#else + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + CYTHON_NCP_UNUSED int wraparound, + CYTHON_NCP_UNUSED int boundscheck) { +#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + PyObject *r = PyList_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } + else if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + PyObject *r = PyTuple_GET_ITEM(o, n); + Py_INCREF(r); + return r; + } + } else { + PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence; + if (likely(m && m->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(m->sq_length)) { + Py_ssize_t l = m->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return m->sq_item(o, i); + } + } +#else + if (is_list || PySequence_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i)); +} + +/* ObjectGetItem */ +#if CYTHON_USE_TYPE_SLOTS +static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject* index) { + PyObject *runerr = NULL; + 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 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)) { + PyErr_Format(PyExc_ImportError, + #if PY_MAJOR_VERSION < 3 + "cannot import name %.230s", PyString_AS_STRING(name)); + #else + "cannot import name %S", name); + #endif + } + return value; +} + +/* HasAttr */ +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { + PyObject *r; + if (unlikely(!__Pyx_PyBaseString_Check(n))) { + PyErr_SetString(PyExc_TypeError, + "hasattr(): attribute name must be string"); + return -1; + } + r = __Pyx_GetAttr(o, n); + if (unlikely(!r)) { + PyErr_Clear(); + return 0; + } else { + Py_DECREF(r); + return 1; + } +} + +/* PyObject_GenericGetAttrNoDict */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject *__Pyx_RaiseGenericGetAttributeError(PyTypeObject *tp, PyObject *attr_name) { + PyErr_Format(PyExc_AttributeError, +#if PY_MAJOR_VERSION >= 3 + "'%.50s' object has no attribute '%U'", + tp->tp_name, attr_name); +#else + "'%.50s' object has no attribute '%.400s'", + tp->tp_name, PyString_AS_STRING(attr_name)); +#endif + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GenericGetAttrNoDict(PyObject* obj, PyObject* attr_name) { + PyObject *descr; + PyTypeObject *tp = Py_TYPE(obj); + if (unlikely(!PyString_Check(attr_name))) { + return PyObject_GenericGetAttr(obj, attr_name); + } + assert(!tp->tp_dictoffset); + descr = _PyType_Lookup(tp, attr_name); + if (unlikely(!descr)) { + return __Pyx_RaiseGenericGetAttributeError(tp, attr_name); + } + Py_INCREF(descr); + #if PY_MAJOR_VERSION < 3 + if (likely(PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_HAVE_CLASS))) + #endif + { + descrgetfunc f = Py_TYPE(descr)->tp_descr_get; + if (unlikely(f)) { + PyObject *res = f(descr, obj, (PyObject *)tp); + Py_DECREF(descr); + return res; + } + } + return descr; +} +#endif + +/* PyObject_GenericGetAttr */ +#if CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP && PY_VERSION_HEX < 0x03070000 +static PyObject* __Pyx_PyObject_GenericGetAttr(PyObject* obj, PyObject* attr_name) { + if (unlikely(Py_TYPE(obj)->tp_dictoffset)) { + return PyObject_GenericGetAttr(obj, attr_name); + } + return __Pyx_PyObject_GenericGetAttrNoDict(obj, attr_name); +} +#endif + +/* SetVTable */ +static int __Pyx_SetVtable(PyObject *dict, void *vtable) { +#if PY_VERSION_HEX >= 0x02070000 + PyObject *ob = PyCapsule_New(vtable, 0, 0); +#else + PyObject *ob = PyCObject_FromVoidPtr(vtable, 0); +#endif + if (!ob) + goto bad; + if (PyDict_SetItem(dict, __pyx_n_s_pyx_vtable, ob) < 0) + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +/* PyObjectGetAttrStrNoError */ +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS && PY_VERSION_HEX >= 0x030700B1 + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +} + +/* SetupReduce */ +static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStr(meth, __pyx_n_s_name_2); + if (likely(name_attr)) { + ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); + } else { + ret = -1; + } + if (unlikely(ret < 0)) { + PyErr_Clear(); + ret = 0; + } + Py_XDECREF(name_attr); + return ret; +} +static int __Pyx_setup_reduce(PyObject* type_obj) { + int ret = 0; + PyObject *object_reduce = NULL; + PyObject *object_getstate = NULL; + PyObject *object_reduce_ex = NULL; + PyObject *reduce = NULL; + PyObject *reduce_ex = NULL; + PyObject *reduce_cython = NULL; + PyObject *setstate = NULL; + PyObject *setstate_cython = NULL; + PyObject *getstate = NULL; +#if CYTHON_USE_PYTYPE_LOOKUP + getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_n_s_getstate); +#else + getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_getstate); + if (!getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (getstate) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_getstate); +#else + object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_n_s_getstate); + if (!object_getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (object_getstate != getstate) { + goto __PYX_GOOD; + } + } +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#else + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#endif + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; + if (reduce_ex == object_reduce_ex) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#else + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_n_s_reduce); if (!object_reduce) goto __PYX_BAD; +#endif + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_reduce); if (unlikely(!reduce)) goto __PYX_BAD; + if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_n_s_reduce_cython)) { + reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_reduce_cython); + if (likely(reduce_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (reduce == object_reduce || PyErr_Occurred()) { + goto __PYX_BAD; + } + setstate = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_n_s_setstate); + if (!setstate) PyErr_Clear(); + if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_n_s_setstate_cython)) { + setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_n_s_setstate_cython); + if (likely(setstate_cython)) { + ret = PyDict_SetItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = PyDict_DelItem(((PyTypeObject*)type_obj)->tp_dict, __pyx_n_s_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (!setstate || PyErr_Occurred()) { + goto __PYX_BAD; + } + } + PyType_Modified((PyTypeObject*)type_obj); + } + } + goto __PYX_GOOD; +__PYX_BAD: + if (!PyErr_Occurred()) + PyErr_Format(PyExc_RuntimeError, "Unable to initialize pickling for %s", ((PyTypeObject*)type_obj)->tp_name); + ret = -1; +__PYX_GOOD: +#if !CYTHON_USE_PYTYPE_LOOKUP + Py_XDECREF(object_reduce); + Py_XDECREF(object_reduce_ex); + Py_XDECREF(object_getstate); + Py_XDECREF(getstate); +#endif + Py_XDECREF(reduce); + Py_XDECREF(reduce_ex); + Py_XDECREF(reduce_cython); + Py_XDECREF(setstate); + Py_XDECREF(setstate_cython); + return ret; +} + +/* CLineInTraceback */ +#ifndef CYTHON_CLINE_IN_TRACEBACK +static int __Pyx_CLineForTraceback(CYTHON_UNUSED PyThreadState *tstate, int c_line) { + PyObject *use_cline; + PyObject *ptype, *pvalue, *ptraceback; +#if CYTHON_COMPILING_IN_CPYTHON + PyObject **cython_runtime_dict; +#endif + if (unlikely(!__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); +#if CYTHON_COMPILING_IN_CPYTHON + cython_runtime_dict = _PyObject_GetDictPtr(__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, *cython_runtime_dict, + __Pyx_PyDict_GetItemStr(*cython_runtime_dict, __pyx_n_s_cline_in_traceback)) + } else +#endif + { + PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback); + if (use_cline_obj) { + use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True; + Py_DECREF(use_cline_obj); + } else { + PyErr_Clear(); + use_cline = NULL; + } + } + if (!use_cline) { + c_line = 0; + (void) PyObject_SetAttr(__pyx_cython_runtime, __pyx_n_s_cline_in_traceback, Py_False); + } + else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache */ +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } +} +static PyCodeObject *__pyx_find_code_object(int code_line) { + PyCodeObject* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!__pyx_code_cache.entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if (unlikely(pos >= __pyx_code_cache.count) || unlikely(__pyx_code_cache.entries[pos].code_line != code_line)) { + return NULL; + } + code_object = __pyx_code_cache.entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object) { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = __pyx_code_cache.entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = 64; + __pyx_code_cache.count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(__pyx_code_cache.entries, __pyx_code_cache.count, code_line); + if ((pos < __pyx_code_cache.count) && unlikely(__pyx_code_cache.entries[pos].code_line == code_line)) { + PyCodeObject* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_DECREF(tmp); + return; + } + if (__pyx_code_cache.count == __pyx_code_cache.max_count) { + int new_max = __pyx_code_cache.max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + __pyx_code_cache.entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + __pyx_code_cache.entries = entries; + __pyx_code_cache.max_count = new_max; + } + for (i=__pyx_code_cache.count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + __pyx_code_cache.count++; + Py_INCREF(code_object); +} + +/* AddTraceback */ +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif +static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = NULL; + PyObject *py_funcname = NULL; + #if PY_MAJOR_VERSION < 3 + PyObject *py_srcfile = NULL; + py_srcfile = PyString_FromString(filename); + if (!py_srcfile) goto bad; + #endif + if (c_line) { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + #else + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + funcname = PyUnicode_AsUTF8(py_funcname); + if (!funcname) goto bad; + #endif + } + else { + #if PY_MAJOR_VERSION < 3 + py_funcname = PyString_FromString(funcname); + if (!py_funcname) goto bad; + #endif + } + #if PY_MAJOR_VERSION < 3 + py_code = __Pyx_PyCode_New( + 0, + 0, + 0, + 0, + 0, + __pyx_empty_bytes, /*PyObject *code,*/ + __pyx_empty_tuple, /*PyObject *consts,*/ + __pyx_empty_tuple, /*PyObject *names,*/ + __pyx_empty_tuple, /*PyObject *varnames,*/ + __pyx_empty_tuple, /*PyObject *freevars,*/ + __pyx_empty_tuple, /*PyObject *cellvars,*/ + py_srcfile, /*PyObject *filename,*/ + py_funcname, /*PyObject *name,*/ + py_line, + __pyx_empty_bytes /*PyObject *lnotab*/ + ); + Py_DECREF(py_srcfile); + #else + py_code = PyCode_NewEmpty(filename, funcname, py_line); + #endif + Py_XDECREF(py_funcname); // XDECREF since it's only set on Py3 if cline + return py_code; +bad: + Py_XDECREF(py_funcname); + #if PY_MAJOR_VERSION < 3 + Py_XDECREF(py_srcfile); + #endif + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject *ptype, *pvalue, *ptraceback; + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); + } + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) { + /* If the code object creation fails, then we should clear the + fetched exception references and propagate the new exception */ + Py_XDECREF(ptype); + Py_XDECREF(pvalue); + Py_XDECREF(ptraceback); + goto bad; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); +bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); +} + +#if PY_MAJOR_VERSION < 3 +static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) { + if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags); + if (__Pyx_TypeCheck(obj, __pyx_array_type)) return __pyx_array_getbuffer(obj, view, flags); + if (__Pyx_TypeCheck(obj, __pyx_memoryview_type)) return __pyx_memoryview_getbuffer(obj, view, flags); + PyErr_Format(PyExc_TypeError, "'%.200s' does not have the buffer interface", Py_TYPE(obj)->tp_name); + return -1; +} +static void __Pyx_ReleaseBuffer(Py_buffer *view) { + PyObject *obj = view->obj; + if (!obj) return; + if (PyObject_CheckBuffer(obj)) { + PyBuffer_Release(view); + return; + } + if ((0)) {} + view->obj = NULL; + Py_DECREF(obj); +} +#endif + + +/* MemviewSliceIsContig */ +static int +__pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim) +{ + int i, index, step, start; + Py_ssize_t itemsize = mvs.memview->view.itemsize; + if (order == 'F') { + step = 1; + start = 0; + } else { + step = -1; + start = ndim - 1; + } + for (i = 0; i < ndim; i++) { + index = start + step * i; + if (mvs.suboffsets[index] >= 0 || mvs.strides[index] != itemsize) + return 0; + itemsize *= mvs.shape[index]; + } + return 1; +} + +/* OverlappingSlices */ +static void +__pyx_get_array_memory_extents(__Pyx_memviewslice *slice, + void **out_start, void **out_end, + int ndim, size_t itemsize) +{ + char *start, *end; + int i; + start = end = slice->data; + for (i = 0; i < ndim; i++) { + Py_ssize_t stride = slice->strides[i]; + Py_ssize_t extent = slice->shape[i]; + if (extent == 0) { + *out_start = *out_end = start; + return; + } else { + if (stride > 0) + end += stride * (extent - 1); + else + start += stride * (extent - 1); + } + } + *out_start = start; + *out_end = end + itemsize; +} +static int +__pyx_slices_overlap(__Pyx_memviewslice *slice1, + __Pyx_memviewslice *slice2, + int ndim, size_t itemsize) +{ + void *start1, *end1, *start2, *end2; + __pyx_get_array_memory_extents(slice1, &start1, &end1, ndim, itemsize); + __pyx_get_array_memory_extents(slice2, &start2, &end2, ndim, itemsize); + return (start1 < end2) && (start2 < end1); +} + +/* Capsule */ +static CYTHON_INLINE PyObject * +__pyx_capsule_create(void *p, CYTHON_UNUSED const char *sig) +{ + PyObject *cobj; +#if PY_VERSION_HEX >= 0x02070000 + cobj = PyCapsule_New(p, sig, NULL); +#else + cobj = PyCObject_FromVoidPtr(p, NULL); +#endif + return cobj; +} + +/* IsLittleEndian */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) +{ + union { + uint32_t u32; + uint8_t u8[4]; + } S; + S.u32 = 0x01020304; + return S.u8[0] == 4; +} + +/* BufferFormatCheck */ +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + __Pyx_TypeInfo* type) { + stack[0].field = &ctx->root; + stack[0].parent_offset = 0; + ctx->root.type = type; + ctx->root.name = "buffer dtype"; + ctx->root.offset = 0; + ctx->head = stack; + ctx->head->field = &ctx->root; + ctx->fmt_offset = 0; + ctx->head->parent_offset = 0; + ctx->new_packmode = '@'; + ctx->enc_packmode = '@'; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->is_complex = 0; + ctx->is_valid_array = 0; + ctx->struct_alignment = 0; + while (type->typegroup == 'S') { + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = 0; + type = type->fields->type; + } +} +static int __Pyx_BufFmt_ParseNumber(const char** ts) { + int count; + const char* t = *ts; + if (*t < '0' || *t > '9') { + return -1; + } else { + count = *t++ - '0'; + while (*t >= '0' && *t <= '9') { + count *= 10; + count += *t++ - '0'; + } + } + *ts = t; + return count; +} +static int __Pyx_BufFmt_ExpectNumber(const char **ts) { + int number = __Pyx_BufFmt_ParseNumber(ts); + if (number == -1) + PyErr_Format(PyExc_ValueError,\ + "Does not understand character buffer dtype format string ('%c')", **ts); + return number; +} +static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { + PyErr_Format(PyExc_ValueError, + "Unexpected format string character: '%c'", ch); +} +static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { + switch (ch) { + case '?': return "'bool'"; + case 'c': return "'char'"; + case 'b': return "'signed char'"; + case 'B': return "'unsigned char'"; + case 'h': return "'short'"; + case 'H': return "'unsigned short'"; + case 'i': return "'int'"; + case 'I': return "'unsigned int'"; + case 'l': return "'long'"; + case 'L': return "'unsigned long'"; + case 'q': return "'long long'"; + case 'Q': return "'unsigned long long'"; + case 'f': return (is_complex ? "'complex float'" : "'float'"); + case 'd': return (is_complex ? "'complex double'" : "'double'"); + case 'g': return (is_complex ? "'complex long double'" : "'long double'"); + case 'T': return "a struct"; + case 'O': return "Python object"; + case 'P': return "a pointer"; + case 's': case 'p': return "a string"; + case 0: return "end"; + default: return "unparseable format string"; + } +} +static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return 2; + case 'i': case 'I': case 'l': case 'L': return 4; + case 'q': case 'Q': return 8; + case 'f': return (is_complex ? 8 : 4); + case 'd': return (is_complex ? 16 : 8); + case 'g': { + PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); + return 0; + } + case 'O': case 'P': return sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(short); + case 'i': case 'I': return sizeof(int); + case 'l': case 'L': return sizeof(long); + #ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(PY_LONG_LONG); + #endif + case 'f': return sizeof(float) * (is_complex ? 2 : 1); + case 'd': return sizeof(double) * (is_complex ? 2 : 1); + case 'g': return sizeof(long double) * (is_complex ? 2 : 1); + case 'O': case 'P': return sizeof(void*); + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +typedef struct { char c; short x; } __Pyx_st_short; +typedef struct { char c; int x; } __Pyx_st_int; +typedef struct { char c; long x; } __Pyx_st_long; +typedef struct { char c; float x; } __Pyx_st_float; +typedef struct { char c; double x; } __Pyx_st_double; +typedef struct { char c; long double x; } __Pyx_st_longdouble; +typedef struct { char c; void *x; } __Pyx_st_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_st_float) - sizeof(float); + case 'd': return sizeof(__Pyx_st_double) - sizeof(double); + case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +/* These are for computing the padding at the end of the struct to align + on the first member of the struct. This will probably the same as above, + but we don't have any guarantees. + */ +typedef struct { short x; char c; } __Pyx_pad_short; +typedef struct { int x; char c; } __Pyx_pad_int; +typedef struct { long x; char c; } __Pyx_pad_long; +typedef struct { float x; char c; } __Pyx_pad_float; +typedef struct { double x; char c; } __Pyx_pad_double; +typedef struct { long double x; char c; } __Pyx_pad_longdouble; +typedef struct { void *x; char c; } __Pyx_pad_void_p; +#ifdef HAVE_LONG_LONG +typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +#endif +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, CYTHON_UNUSED int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); +#ifdef HAVE_LONG_LONG + case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); +#endif + case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); + case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); + case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { + switch (ch) { + case 'c': + return 'H'; + case 'b': case 'h': case 'i': + case 'l': case 'q': case 's': case 'p': + return 'I'; + case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': + return 'U'; + case 'f': case 'd': case 'g': + return (is_complex ? 'C' : 'R'); + case 'O': + return 'O'; + case 'P': + return 'P'; + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { + if (ctx->head == NULL || ctx->head->field == &ctx->root) { + const char* expected; + const char* quote; + if (ctx->head == NULL) { + expected = "end"; + quote = ""; + } else { + expected = ctx->head->field->type->name; + quote = "'"; + } + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected %s%s%s but got %s", + quote, expected, quote, + __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); + } else { + __Pyx_StructField* field = ctx->head->field; + __Pyx_StructField* parent = (ctx->head - 1)->field; + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", + field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), + parent->type->name, field->name); + } +} +static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { + char group; + size_t size, offset, arraysize = 1; + if (ctx->enc_type == 0) return 0; + if (ctx->head->field->type->arraysize[0]) { + int i, ndim = 0; + if (ctx->enc_type == 's' || ctx->enc_type == 'p') { + ctx->is_valid_array = ctx->head->field->type->ndim == 1; + ndim = 1; + if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %zu", + ctx->head->field->type->arraysize[0], ctx->enc_count); + return -1; + } + } + if (!ctx->is_valid_array) { + PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", + ctx->head->field->type->ndim, ndim); + return -1; + } + for (i = 0; i < ctx->head->field->type->ndim; i++) { + arraysize *= ctx->head->field->type->arraysize[i]; + } + ctx->is_valid_array = 0; + ctx->enc_count = 1; + } + group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); + do { + __Pyx_StructField* field = ctx->head->field; + __Pyx_TypeInfo* type = field->type; + if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { + size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); + } else { + size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); + } + if (ctx->enc_packmode == '@') { + size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); + size_t align_mod_offset; + if (align_at == 0) return -1; + align_mod_offset = ctx->fmt_offset % align_at; + if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; + if (ctx->struct_alignment == 0) + ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, + ctx->is_complex); + } + if (type->size != size || type->typegroup != group) { + if (type->typegroup == 'C' && type->fields != NULL) { + size_t parent_offset = ctx->head->parent_offset + field->offset; + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = parent_offset; + continue; + } + if ((type->typegroup == 'H' || group == 'H') && type->size == size) { + } else { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + } + offset = ctx->head->parent_offset + field->offset; + if (ctx->fmt_offset != offset) { + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", + (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); + return -1; + } + ctx->fmt_offset += size; + if (arraysize) + ctx->fmt_offset += (arraysize - 1) * size; + --ctx->enc_count; + while (1) { + if (field == &ctx->root) { + ctx->head = NULL; + if (ctx->enc_count != 0) { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + break; + } + ctx->head->field = ++field; + if (field->type == NULL) { + --ctx->head; + field = ctx->head->field; + continue; + } else if (field->type->typegroup == 'S') { + size_t parent_offset = ctx->head->parent_offset + field->offset; + if (field->type->fields->type == NULL) continue; + field = field->type->fields; + ++ctx->head; + ctx->head->field = field; + ctx->head->parent_offset = parent_offset; + break; + } else { + break; + } + } + } while (ctx->enc_count); + ctx->enc_type = 0; + ctx->is_complex = 0; + return 0; +} +static PyObject * +__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) +{ + const char *ts = *tsp; + int i = 0, number, ndim; + ++ts; + if (ctx->new_count != 1) { + PyErr_SetString(PyExc_ValueError, + "Cannot handle repeated arrays in format string"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ndim = ctx->head->field->type->ndim; + while (*ts && *ts != ')') { + switch (*ts) { + case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; + default: break; + } + number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) + return PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + if (*ts != ',' && *ts != ')') + return PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + if (*ts == ',') ts++; + i++; + } + if (i != ndim) + return PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return NULL; + } + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return Py_None; +} +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { + int got_Z = 0; + while (1) { + switch(*ts) { + case 0: + if (ctx->enc_type != 0 && ctx->head == NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (ctx->head != NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + return ts; + case ' ': + case '\r': + case '\n': + ++ts; + break; + case '<': + if (!__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '>': + case '!': + if (__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '=': + case '@': + case '^': + ctx->new_packmode = *ts++; + break; + case 'T': + { + const char* ts_after_sub; + size_t i, struct_count = ctx->new_count; + size_t struct_alignment = ctx->struct_alignment; + ctx->new_count = 1; + ++ts; + if (*ts != '{') { + PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + ctx->enc_count = 0; + ctx->struct_alignment = 0; + ++ts; + ts_after_sub = ts; + for (i = 0; i != struct_count; ++i) { + ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); + if (!ts_after_sub) return NULL; + } + ts = ts_after_sub; + if (struct_alignment) ctx->struct_alignment = struct_alignment; + } + break; + case '}': + { + size_t alignment = ctx->struct_alignment; + ++ts; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + if (alignment && ctx->fmt_offset % alignment) { + ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); + } + } + return ts; + case 'x': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->fmt_offset += ctx->new_count; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->enc_packmode = ctx->new_packmode; + ++ts; + break; + case 'Z': + got_Z = 1; + ++ts; + if (*ts != 'f' && *ts != 'd' && *ts != 'g') { + __Pyx_BufFmt_RaiseUnexpectedChar('Z'); + return NULL; + } + CYTHON_FALLTHROUGH; + case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'l': case 'L': case 'q': case 'Q': + case 'f': case 'd': case 'g': + case 'O': case 'p': + if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && + (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { + ctx->enc_count += ctx->new_count; + ctx->new_count = 1; + got_Z = 0; + ++ts; + break; + } + CYTHON_FALLTHROUGH; + case 's': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_count = ctx->new_count; + ctx->enc_packmode = ctx->new_packmode; + ctx->enc_type = *ts; + ctx->is_complex = got_Z; + ++ts; + ctx->new_count = 1; + got_Z = 0; + break; + case ':': + ++ts; + while(*ts != ':') ++ts; + ++ts; + break; + case '(': + if (!__pyx_buffmt_parse_array(ctx, &ts)) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; + } + } + } +} + +/* TypeInfoCompare */ + static int +__pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b) +{ + int i; + if (!a || !b) + return 0; + if (a == b) + return 1; + if (a->size != b->size || a->typegroup != b->typegroup || + a->is_unsigned != b->is_unsigned || a->ndim != b->ndim) { + if (a->typegroup == 'H' || b->typegroup == 'H') { + return a->size == b->size; + } else { + return 0; + } + } + if (a->ndim) { + for (i = 0; i < a->ndim; i++) + if (a->arraysize[i] != b->arraysize[i]) + return 0; + } + if (a->typegroup == 'S') { + if (a->flags != b->flags) + return 0; + if (a->fields || b->fields) { + if (!(a->fields && b->fields)) + return 0; + for (i = 0; a->fields[i].type && b->fields[i].type; i++) { + __Pyx_StructField *field_a = a->fields + i; + __Pyx_StructField *field_b = b->fields + i; + if (field_a->offset != field_b->offset || + !__pyx_typeinfo_cmp(field_a->type, field_b->type)) + return 0; + } + return !a->fields[i].type && !b->fields[i].type; + } + } + return 1; +} + +/* MemviewSliceValidateAndInit */ + static int +__pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec) +{ + if (buf->shape[dim] <= 1) + return 1; + if (buf->strides) { + if (spec & __Pyx_MEMVIEW_CONTIG) { + if (spec & (__Pyx_MEMVIEW_PTR|__Pyx_MEMVIEW_FULL)) { + if (unlikely(buf->strides[dim] != sizeof(void *))) { + PyErr_Format(PyExc_ValueError, + "Buffer is not indirectly contiguous " + "in dimension %d.", dim); + goto fail; + } + } else if (unlikely(buf->strides[dim] != buf->itemsize)) { + PyErr_SetString(PyExc_ValueError, + "Buffer and memoryview are not contiguous " + "in the same dimension."); + goto fail; + } + } + if (spec & __Pyx_MEMVIEW_FOLLOW) { + Py_ssize_t stride = buf->strides[dim]; + if (stride < 0) + stride = -stride; + if (unlikely(stride < buf->itemsize)) { + PyErr_SetString(PyExc_ValueError, + "Buffer and memoryview are not contiguous " + "in the same dimension."); + goto fail; + } + } + } else { + if (unlikely(spec & __Pyx_MEMVIEW_CONTIG && dim != ndim - 1)) { + PyErr_Format(PyExc_ValueError, + "C-contiguous buffer is not contiguous in " + "dimension %d", dim); + goto fail; + } else if (unlikely(spec & (__Pyx_MEMVIEW_PTR))) { + PyErr_Format(PyExc_ValueError, + "C-contiguous buffer is not indirect in " + "dimension %d", dim); + goto fail; + } else if (unlikely(buf->suboffsets)) { + PyErr_SetString(PyExc_ValueError, + "Buffer exposes suboffsets but no strides"); + goto fail; + } + } + return 1; +fail: + return 0; +} +static int +__pyx_check_suboffsets(Py_buffer *buf, int dim, CYTHON_UNUSED int ndim, int spec) +{ + if (spec & __Pyx_MEMVIEW_DIRECT) { + if (unlikely(buf->suboffsets && buf->suboffsets[dim] >= 0)) { + PyErr_Format(PyExc_ValueError, + "Buffer not compatible with direct access " + "in dimension %d.", dim); + goto fail; + } + } + if (spec & __Pyx_MEMVIEW_PTR) { + if (unlikely(!buf->suboffsets || (buf->suboffsets[dim] < 0))) { + PyErr_Format(PyExc_ValueError, + "Buffer is not indirectly accessible " + "in dimension %d.", dim); + goto fail; + } + } + return 1; +fail: + return 0; +} +static int +__pyx_verify_contig(Py_buffer *buf, int ndim, int c_or_f_flag) +{ + int i; + if (c_or_f_flag & __Pyx_IS_F_CONTIG) { + Py_ssize_t stride = 1; + for (i = 0; i < ndim; i++) { + if (unlikely(stride * buf->itemsize != buf->strides[i] && buf->shape[i] > 1)) { + PyErr_SetString(PyExc_ValueError, + "Buffer not fortran contiguous."); + goto fail; + } + stride = stride * buf->shape[i]; + } + } else if (c_or_f_flag & __Pyx_IS_C_CONTIG) { + Py_ssize_t stride = 1; + for (i = ndim - 1; i >- 1; i--) { + if (unlikely(stride * buf->itemsize != buf->strides[i] && buf->shape[i] > 1)) { + PyErr_SetString(PyExc_ValueError, + "Buffer not C contiguous."); + goto fail; + } + stride = stride * buf->shape[i]; + } + } + return 1; +fail: + return 0; +} +static int __Pyx_ValidateAndInit_memviewslice( + int *axes_specs, + int c_or_f_flag, + int buf_flags, + int ndim, + __Pyx_TypeInfo *dtype, + __Pyx_BufFmt_StackElem stack[], + __Pyx_memviewslice *memviewslice, + PyObject *original_obj) +{ + struct __pyx_memoryview_obj *memview, *new_memview; + __Pyx_RefNannyDeclarations + Py_buffer *buf; + int i, spec = 0, retval = -1; + __Pyx_BufFmt_Context ctx; + int from_memoryview = __pyx_memoryview_check(original_obj); + __Pyx_RefNannySetupContext("ValidateAndInit_memviewslice", 0); + if (from_memoryview && __pyx_typeinfo_cmp(dtype, ((struct __pyx_memoryview_obj *) + original_obj)->typeinfo)) { + memview = (struct __pyx_memoryview_obj *) original_obj; + new_memview = NULL; + } else { + memview = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( + original_obj, buf_flags, 0, dtype); + new_memview = memview; + if (unlikely(!memview)) + goto fail; + } + buf = &memview->view; + if (unlikely(buf->ndim != ndim)) { + PyErr_Format(PyExc_ValueError, + "Buffer has wrong number of dimensions (expected %d, got %d)", + ndim, buf->ndim); + goto fail; + } + if (new_memview) { + __Pyx_BufFmt_Init(&ctx, stack, dtype); + if (unlikely(!__Pyx_BufFmt_CheckString(&ctx, buf->format))) goto fail; + } + if (unlikely((unsigned) buf->itemsize != dtype->size)) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "u byte%s) " + "does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "u byte%s)", + buf->itemsize, + (buf->itemsize > 1) ? "s" : "", + dtype->name, + dtype->size, + (dtype->size > 1) ? "s" : ""); + goto fail; + } + if (buf->len > 0) { + for (i = 0; i < ndim; i++) { + spec = axes_specs[i]; + if (unlikely(!__pyx_check_strides(buf, i, ndim, spec))) + goto fail; + if (unlikely(!__pyx_check_suboffsets(buf, i, ndim, spec))) + goto fail; + } + if (unlikely(buf->strides && !__pyx_verify_contig(buf, ndim, c_or_f_flag))) + goto fail; + } + if (unlikely(__Pyx_init_memviewslice(memview, ndim, memviewslice, + new_memview != NULL) == -1)) { + goto fail; + } + retval = 0; + goto no_fail; +fail: + Py_XDECREF(new_memview); + retval = -1; +no_fail: + __Pyx_RefNannyFinishContext(); + return retval; +} + +/* ObjectToMemviewSlice */ + static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dsds_nn_int32_t(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_STRIDED), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_STRIDED) }; + int retcode; + if (obj == Py_None) { + result.memview = (struct __pyx_memoryview_obj *) Py_None; + return result; + } + retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, 0, + PyBUF_RECORDS_RO | writable_flag, 2, + &__Pyx_TypeInfo_nn_int32_t, stack, + &result, obj); + if (unlikely(retcode == -1)) + goto __pyx_fail; + return result; +__pyx_fail: + result.memview = NULL; + result.data = NULL; + return result; +} + +/* CIntFromPyVerify */ + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) +#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) +#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* MemviewSliceCopyTemplate */ + static __Pyx_memviewslice +__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, + const char *mode, int ndim, + size_t sizeof_dtype, int contig_flag, + int dtype_is_object) +{ + __Pyx_RefNannyDeclarations + int i; + __Pyx_memviewslice new_mvs = { 0, 0, { 0 }, { 0 }, { 0 } }; + struct __pyx_memoryview_obj *from_memview = from_mvs->memview; + Py_buffer *buf = &from_memview->view; + PyObject *shape_tuple = NULL; + PyObject *temp_int = NULL; + struct __pyx_array_obj *array_obj = NULL; + struct __pyx_memoryview_obj *memview_obj = NULL; + __Pyx_RefNannySetupContext("__pyx_memoryview_copy_new_contig", 0); + for (i = 0; i < ndim; i++) { + if (unlikely(from_mvs->suboffsets[i] >= 0)) { + PyErr_Format(PyExc_ValueError, "Cannot copy memoryview slice with " + "indirect dimensions (axis %d)", i); + goto fail; + } + } + shape_tuple = PyTuple_New(ndim); + if (unlikely(!shape_tuple)) { + goto fail; + } + __Pyx_GOTREF(shape_tuple); + for(i = 0; i < ndim; i++) { + temp_int = PyInt_FromSsize_t(from_mvs->shape[i]); + if(unlikely(!temp_int)) { + goto fail; + } else { + PyTuple_SET_ITEM(shape_tuple, i, temp_int); + temp_int = NULL; + } + } + array_obj = __pyx_array_new(shape_tuple, sizeof_dtype, buf->format, (char *) mode, NULL); + if (unlikely(!array_obj)) { + goto fail; + } + __Pyx_GOTREF(array_obj); + memview_obj = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( + (PyObject *) array_obj, contig_flag, + dtype_is_object, + from_mvs->memview->typeinfo); + if (unlikely(!memview_obj)) + goto fail; + if (unlikely(__Pyx_init_memviewslice(memview_obj, ndim, &new_mvs, 1) < 0)) + goto fail; + if (unlikely(__pyx_memoryview_copy_contents(*from_mvs, new_mvs, ndim, ndim, + dtype_is_object) < 0)) + goto fail; + goto no_fail; +fail: + __Pyx_XDECREF(new_mvs.memview); + new_mvs.memview = NULL; + new_mvs.data = NULL; +no_fail: + __Pyx_XDECREF(shape_tuple); + __Pyx_XDECREF(temp_int); + __Pyx_XDECREF(array_obj); + __Pyx_RefNannyFinishContext(); + return new_mvs; +} + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(int) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(int, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (int) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case 1: __PYX_VERIFY_RETURN_INT(int, digit, digits[0]) + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 2 * PyLong_SHIFT) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 3 * PyLong_SHIFT) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) >= 4 * PyLong_SHIFT) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(int) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (int) 0; + case -1: __PYX_VERIFY_RETURN_INT(int, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(int, digit, +digits[0]) + case -2: + if (8 * sizeof(int) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(int) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(int) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(int) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(int) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(int) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(int) - 1 > 4 * PyLong_SHIFT) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } +#endif + if (sizeof(int) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + int val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (int) -1; + } + } else { + int val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (int) -1; + val = __Pyx_PyInt_As_int(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const long neg_one = (long) -1, const_zero = (long) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(long) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(long, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (long) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case 1: __PYX_VERIFY_RETURN_INT(long, digit, digits[0]) + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 2 * PyLong_SHIFT) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 3 * PyLong_SHIFT) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) >= 4 * PyLong_SHIFT) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(long) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (long) 0; + case -1: __PYX_VERIFY_RETURN_INT(long, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(long, digit, +digits[0]) + case -2: + if (8 * sizeof(long) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(long) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(long) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(long) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } +#endif + if (sizeof(long) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + long val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (long) -1; + } + } else { + long val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (long) -1; + val = __Pyx_PyInt_As_long(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; +} + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyInt_From_int(int value) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyInt_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); +#endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyInt_FromLong((long) value); +#ifdef HAVE_LONG_LONG + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); +#endif + } + } + { + int one = 1; int little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&value; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + } +} + +/* CIntFromPy */ + static CYTHON_INLINE char __Pyx_PyInt_As_char(PyObject *x) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const char neg_one = (char) -1, const_zero = (char) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x))) { + if (sizeof(char) < sizeof(long)) { + __PYX_VERIFY_RETURN_INT(char, long, PyInt_AS_LONG(x)) + } else { + long val = PyInt_AS_LONG(x); + if (is_unsigned && unlikely(val < 0)) { + goto raise_neg_overflow; + } + return (char) val; + } + } else +#endif + if (likely(PyLong_Check(x))) { + if (is_unsigned) { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (char) 0; + case 1: __PYX_VERIFY_RETURN_INT(char, digit, digits[0]) + case 2: + if (8 * sizeof(char) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 2 * PyLong_SHIFT) { + return (char) (((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + case 3: + if (8 * sizeof(char) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 3 * PyLong_SHIFT) { + return (char) (((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + case 4: + if (8 * sizeof(char) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) >= 4 * PyLong_SHIFT) { + return (char) (((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + } +#endif +#if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } +#else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (char) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } +#endif + if (sizeof(char) <= sizeof(unsigned long)) { + __PYX_VERIFY_RETURN_INT_EXC(char, unsigned long, PyLong_AsUnsignedLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(char) <= sizeof(unsigned PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) +#endif + } + } else { +#if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)x)->ob_digit; + switch (Py_SIZE(x)) { + case 0: return (char) 0; + case -1: __PYX_VERIFY_RETURN_INT(char, sdigit, (sdigit) (-(sdigit)digits[0])) + case 1: __PYX_VERIFY_RETURN_INT(char, digit, +digits[0]) + case -2: + if (8 * sizeof(char) - 1 > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 2: + if (8 * sizeof(char) > 1 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 2 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + return (char) ((((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case -3: + if (8 * sizeof(char) - 1 > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 3: + if (8 * sizeof(char) > 2 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 3 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + return (char) ((((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case -4: + if (8 * sizeof(char) - 1 > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) { + return (char) (((char)-1)*(((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 4: + if (8 * sizeof(char) > 3 * PyLong_SHIFT) { + if (8 * sizeof(unsigned long) > 4 * PyLong_SHIFT) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if (8 * sizeof(char) - 1 > 4 * PyLong_SHIFT) { + return (char) ((((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + } +#endif + if (sizeof(char) <= sizeof(long)) { + __PYX_VERIFY_RETURN_INT_EXC(char, long, PyLong_AsLong(x)) +#ifdef HAVE_LONG_LONG + } else if (sizeof(char) <= sizeof(PY_LONG_LONG)) { + __PYX_VERIFY_RETURN_INT_EXC(char, PY_LONG_LONG, PyLong_AsLongLong(x)) +#endif + } + } + { +#if CYTHON_COMPILING_IN_PYPY && !defined(_PyLong_AsByteArray) + PyErr_SetString(PyExc_RuntimeError, + "_PyLong_AsByteArray() not available in PyPy, cannot convert large numbers"); +#else + char val; + PyObject *v = __Pyx_PyNumber_IntOrLong(x); + #if PY_MAJOR_VERSION < 3 + if (likely(v) && !PyLong_Check(v)) { + PyObject *tmp = v; + v = PyNumber_Long(tmp); + Py_DECREF(tmp); + } + #endif + if (likely(v)) { + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + int ret = _PyLong_AsByteArray((PyLongObject *)v, + bytes, sizeof(val), + is_little, !is_unsigned); + Py_DECREF(v); + if (likely(!ret)) + return val; + } +#endif + return (char) -1; + } + } else { + char val; + PyObject *tmp = __Pyx_PyNumber_IntOrLong(x); + if (!tmp) return (char) -1; + val = __Pyx_PyInt_As_char(tmp); + Py_DECREF(tmp); + return val; + } +raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to char"); + return (char) -1; +raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to char"); + return (char) -1; +} + +/* CheckBinaryVersion */ + static int __Pyx_check_binary_version(void) { + char ctversion[5]; + int same=1, i, found_dot; + const char* rt_from_call = Py_GetVersion(); + PyOS_snprintf(ctversion, 5, "%d.%d", PY_MAJOR_VERSION, PY_MINOR_VERSION); + found_dot = 0; + for (i = 0; i < 4; i++) { + if (!ctversion[i]) { + same = (rt_from_call[i] < '0' || rt_from_call[i] > '9'); + break; + } + if (rt_from_call[i] != ctversion[i]) { + same = 0; + break; + } + } + if (!same) { + char rtversion[5] = {'\0'}; + char message[200]; + for (i=0; i<4; ++i) { + if (rt_from_call[i] == '.') { + if (found_dot) break; + found_dot = 1; + } else if (rt_from_call[i] < '0' || rt_from_call[i] > '9') { + break; + } + rtversion[i] = rt_from_call[i]; + } + PyOS_snprintf(message, sizeof(message), + "compiletime version %s of module '%.100s' " + "does not match runtime version %s", + ctversion, __Pyx_MODULE_NAME, rtversion); + return PyErr_WarnEx(NULL, message, 1); + } + return 0; +} + +/* InitStrings */ + static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) { + while (t->p) { + #if PY_MAJOR_VERSION < 3 + if (t->is_unicode) { + *t->p = PyUnicode_DecodeUTF8(t->s, t->n - 1, NULL); + } else if (t->intern) { + *t->p = PyString_InternFromString(t->s); + } else { + *t->p = PyString_FromStringAndSize(t->s, t->n - 1); + } + #else + if (t->is_unicode | t->is_str) { + if (t->intern) { + *t->p = PyUnicode_InternFromString(t->s); + } else if (t->encoding) { + *t->p = PyUnicode_Decode(t->s, t->n - 1, t->encoding, NULL); + } else { + *t->p = PyUnicode_FromStringAndSize(t->s, t->n - 1); + } + } else { + *t->p = PyBytes_FromStringAndSize(t->s, t->n - 1); + } + #endif + if (!*t->p) + return -1; + if (PyObject_Hash(*t->p) == -1) + return -1; + ++t; + } + return 0; +} + +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + return __Pyx_PyUnicode_FromStringAndSize(c_str, (Py_ssize_t)strlen(c_str)); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT +#if !CYTHON_PEP393_ENABLED +static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + char* defenc_c; + PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL); + if (!defenc) return NULL; + defenc_c = PyBytes_AS_STRING(defenc); +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + { + char* end = defenc_c + PyBytes_GET_SIZE(defenc); + char* c; + for (c = defenc_c; c < end; c++) { + if ((unsigned char) (*c) >= 128) { + PyUnicode_AsASCIIString(o); + return NULL; + } + } + } +#endif + *length = PyBytes_GET_SIZE(defenc); + return defenc_c; +} +#else +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (likely(PyUnicode_IS_ASCII(o))) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +} +#endif +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT + if ( +#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + __Pyx_sys_getdefaultencoding_not_ascii && +#endif + PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif +#if (!CYTHON_COMPILING_IN_PYPY) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE)) + if (PyByteArray_Check(o)) { + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); + } else +#endif + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { + int retval; + if (unlikely(!x)) return -1; + retval = __Pyx_PyObject_IsTrue(x); + Py_DECREF(x); + return retval; +} +static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) { +#if PY_MAJOR_VERSION >= 3 + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type %.200s). " + "The ability to return an instance of a strict subclass of int " + "is deprecated, and may be removed in a future version of Python.", + Py_TYPE(result)->tp_name)) { + Py_DECREF(result); + return NULL; + } + return result; + } +#endif + PyErr_Format(PyExc_TypeError, + "__%.4s__ returned non-%.4s (type %.200s)", + type_name, type_name, Py_TYPE(result)->tp_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + const char *name = NULL; + PyObject *res = NULL; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_Check(x) || PyLong_Check(x))) +#else + if (likely(PyLong_Check(x))) +#endif + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + #if PY_MAJOR_VERSION < 3 + if (m && m->nb_int) { + name = "int"; + res = m->nb_int(x); + } + else if (m && m->nb_long) { + name = "long"; + res = m->nb_long(x); + } + #else + if (likely(m && m->nb_int)) { + name = "int"; + res = m->nb_int(x); + } + #endif +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Int(x); + } +#endif + if (likely(res)) { +#if PY_MAJOR_VERSION < 3 + if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) { +#else + if (unlikely(!PyLong_CheckExact(res))) { +#endif + return __Pyx_PyNumber_IntOrLongWrongResultType(res, name); + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; +#if PY_MAJOR_VERSION < 3 + if (likely(PyInt_CheckExact(b))) { + if (sizeof(Py_ssize_t) >= sizeof(long)) + return PyInt_AS_LONG(b); + else + return PyInt_AsSsize_t(b); + } +#endif + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + const digit* digits = ((PyLongObject*)b)->ob_digit; + const Py_ssize_t size = Py_SIZE(b); + if (likely(__Pyx_sst_abs(size) <= 1)) { + ival = likely(size) ? digits[0] : 0; + if (size == -1) ival = -ival; + return ival; + } else { + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyInt_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { + if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { + return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); +#if PY_MAJOR_VERSION < 3 + } else if (likely(PyInt_CheckExact(o))) { + return PyInt_AS_LONG(o); +#endif + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyInt_AsLong(x); + Py_DECREF(x); + return ival; + } +} +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False); +} +static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) { + return PyInt_FromSize_t(ival); +} + + +#endif /* Py_PYTHON_H */ diff --git a/zoo/board_games/tictactoe/envs/rule_bot_v0.py b/zoo/board_games/tictactoe/envs/rule_bot_v0.py new file mode 100644 index 000000000..7de8ac7cc --- /dev/null +++ b/zoo/board_games/tictactoe/envs/rule_bot_v0.py @@ -0,0 +1,152 @@ +import copy +from collections import namedtuple +from typing import List, Dict, Any, Tuple, Union + +import numpy as np +import torch +from ding.policy.base_policy import Policy +from ding.utils import POLICY_REGISTRY + + +def legal_actions(board): + legal_actions = [] + for i in range(3): + for j in range(3): + if board[i][j] == 0: + legal_actions.append(i * 3 + j) + return legal_actions + + +@POLICY_REGISTRY.register('tictactoe_bot_v0') +class TictactoeBotV0(Policy): + """ + Overview: + Hard coded expert agent for tictactoe env. + """ + config = dict( + # (str) RL policy register name (refer to function "POLICY_REGISTRY"). + type='tictactoe_bot_v0', + cuda=False, + on_policy=True, + learn=dict( + multi_gpu=False, + ), + collect=dict( + unroll_len=1, + ), + eval=dict(), + ) + + def rule_bot_v0(self, obs): + + """ + Overview: + Hard coded expert agent for tictactoe env. + First random sample a action from legal_actions, then take the action that will lead a connect3 of current player's pieces. + Returns: + - action (:obj:`int`): the expert action to take in the current game state. + """ + # To easily calculate expert action, we convert the chessboard notation: + # from player 1: 1, player 2: 2 + # to player 1: -1, player 2: 1 + # TODO: more elegant implementation + board = obs['board'] + current_player_to_compute_bot_action = -1 if obs['to_play'] == 1 else 1 + board = copy.deepcopy(board) + for i in range(board.shape[0]): + for j in range(board.shape[1]): + if board[i][j] == 1: + board[i][j] = -1 + elif board[i][j] == 2: + board[i][j] = 1 + + # first random sample an action from legal_actions + action = np.random.choice(legal_actions(board)) + + # Horizontal and vertical checks + for i in range(3): + if abs(sum(board[i, :])) == 2: + # if i-th horizontal line has two same pieces and one empty position, + # find the index in the i-th horizontal line + ind = np.where(board[i, :] == 0)[0][0] + # convert ind to action + action = np.ravel_multi_index((np.array([i]), np.array([ind])), (3, 3))[0] + if current_player_to_compute_bot_action * sum(board[i, :]) > 0: + # only take the action that will lead a connect3 of current player's pieces + return action + + if abs(sum(board[:, i])) == 2: + # if i-th vertical line has two same pieces and one empty position + # find the index in the i-th vertical line + ind = np.where(board[:, i] == 0)[0][0] + # convert ind to action + action = np.ravel_multi_index((np.array([ind]), np.array([i])), (3, 3))[0] + if current_player_to_compute_bot_action * sum(board[:, i]) > 0: + # only take the action that will lead a connect3 of current player's pieces + return action + + # Diagonal checks + diag = board.diagonal() + anti_diag = np.fliplr(board).diagonal() + if abs(sum(diag)) == 2: + # if diagonal has two same pieces and one empty position + # find the index in the diag vector + ind = np.where(diag == 0)[0][0] + # convert ind to action + action = np.ravel_multi_index((np.array([ind]), np.array([ind])), (3, 3))[0] + if current_player_to_compute_bot_action * sum(diag) > 0: + # only take the action that will lead a connect3 of current player's pieces + return action + + if abs(sum(anti_diag)) == 2: + # if anti-diagonal has two same pieces and one empty position + # find the index in the anti_diag vector + ind = np.where(anti_diag == 0)[0][0] + # convert ind to action + action = np.ravel_multi_index((np.array([ind]), np.array([2 - ind])), (3, 3))[0] + if current_player_to_compute_bot_action * sum(anti_diag) > 0: + # only take the action that will lead a connect3 of current player's pieces + return action + + return action + + def _init_learn(self) -> None: + pass + + def _init_collect(self) -> None: + pass + + def _init_eval(self) -> None: + pass + + def _forward_learn(self, data: dict) -> dict: + pass + + def _forward_collect(self, envs: Dict, obs: Dict, temperature: float = 1) -> Dict[str, torch.Tensor]: + ready_env_id = list(envs.keys()) + output = {} + for env_id in ready_env_id: + action = self.rule_bot_v0(obs[env_id]) + output[env_id] = { + 'action': action, + 'probs': None, + } + return output + + def _forward_eval(self, data: dict) -> dict: + pass + + def _process_transition(self, obs: Any, model_output: dict, timestep: namedtuple) -> dict: + pass + + def _get_train_sample(self, data: list) -> Union[None, List[Any]]: + pass + + def default_model(self) -> Tuple[str, List[str]]: + return 'bot_model', ['lzero.model.bot_model'] + + def _monitor_vars_learn(self) -> List[str]: + pass + + def reset(self): + pass From 089767772c432d3a4a18cb7d62216fa606d2b15d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Thu, 11 May 2023 12:33:32 +0800 Subject: [PATCH 05/34] fix(pu): fix gomoku_rule_bot_v0 --- lzero/entry/train_alphazero_league.py | 24 ++++----- lzero/worker/battle_alphazero_collector.py | 4 +- .../config/gomoku_alphazero_league_config.py | 4 +- .../{rule_bot_v0.py => gomoku_rule_bot_v0.py} | 52 ++++++++----------- .../tictactoe_alphazero_league_config.py | 2 +- ...ule_bot_v0.py => tictactoe_rule_bot_v0.py} | 2 +- 6 files changed, 41 insertions(+), 47 deletions(-) rename zoo/board_games/gomoku/envs/{rule_bot_v0.py => gomoku_rule_bot_v0.py} (89%) rename zoo/board_games/tictactoe/envs/{rule_bot_v0.py => tictactoe_rule_bot_v0.py} (97%) diff --git a/lzero/entry/train_alphazero_league.py b/lzero/entry/train_alphazero_league.py index 26bc8d3fc..c965c1c83 100644 --- a/lzero/entry/train_alphazero_league.py +++ b/lzero/entry/train_alphazero_league.py @@ -174,18 +174,18 @@ def load_checkpoint_fn(player_id: str, ckpt_path: str): set_pkg_seed(seed, use_cuda=cfg.policy.cuda) league_iter = 0 while True: - # if evaluator.should_eval(main_learner.train_iter): - # stop_flag, eval_episode_info = evaluator.eval( - # main_learner.save_checkpoint, main_learner.train_iter, main_collector.envstep - # ) - # win_loss_result = win_loss_draw(eval_episode_info) - # - # # set eval bot rating as 100. - # main_player.rating = league.metric_env.rate_1vsC( - # main_player.rating, league.metric_env.create_rating(mu=100, sigma=1e-8), win_loss_result - # ) - # if stop_flag: - # break + if evaluator.should_eval(main_learner.train_iter): + stop_flag, eval_episode_info = evaluator.eval( + main_learner.save_checkpoint, main_learner.train_iter, main_collector.envstep + ) + win_loss_result = win_loss_draw(eval_episode_info) + + # set eval bot rating as 100. + main_player.rating = league.metric_env.rate_1vsC( + main_player.rating, league.metric_env.create_rating(mu=100, sigma=1e-8), win_loss_result + ) + if stop_flag: + break for player_id, player_ckpt_path in zip(league.active_players_ids, league.active_players_ckpts): tb_logger.add_scalar( diff --git a/lzero/worker/battle_alphazero_collector.py b/lzero/worker/battle_alphazero_collector.py index 7edd88e07..370c05c3e 100644 --- a/lzero/worker/battle_alphazero_collector.py +++ b/lzero/worker/battle_alphazero_collector.py @@ -9,8 +9,8 @@ from ding.torch_utils import to_tensor, to_ndarray from ding.worker.collector.base_serial_collector import ISerialCollector, CachePool, TrajBuffer, INF, \ to_tensor_transitions -from zoo.board_games.tictactoe.envs.rule_bot_v0 import TictactoeBotV0 -from zoo.board_games.gomoku.envs.rule_bot_v0 import GomokuBotV0 +from zoo.board_games.tictactoe.envs.tictactoe_rule_bot_v0 import TictactoeBotV0 +from zoo.board_games.gomoku.envs.gomoku_rule_bot_v0 import GomokuBotV0 @SERIAL_COLLECTOR_REGISTRY.register('episode_alphazero_battle') class BattleAlphaZeroCollector(ISerialCollector): diff --git a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py index 405f38608..191846b46 100644 --- a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py +++ b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py @@ -22,7 +22,7 @@ # update_per_collect = 5 # batch_size = 2 # max_env_step = int(2e5) -# sp_prob = 0.8 +# sp_prob = 0. # ============================================================== # end of the most frequently changed config specified by the user # ============================================================== @@ -76,7 +76,7 @@ # log_freq=2, # debug player_category=['gomoku'], # path to save policy of league player, user can specify this field - path_policy=f"gomoku_alphazero_league_policy_ckpt_sp-{sp_prob}", + path_policy=f"data_az_ptree_league/gomoku_alphazero_league_policy_ckpt_sp-{sp_prob}", active_players=dict(main_player=1, ), main_player=dict( # An active player will be considered trained enough for snapshot after two phase steps. diff --git a/zoo/board_games/gomoku/envs/rule_bot_v0.py b/zoo/board_games/gomoku/envs/gomoku_rule_bot_v0.py similarity index 89% rename from zoo/board_games/gomoku/envs/rule_bot_v0.py rename to zoo/board_games/gomoku/envs/gomoku_rule_bot_v0.py index 7a2f33e2f..6985081d0 100644 --- a/zoo/board_games/gomoku/envs/rule_bot_v0.py +++ b/zoo/board_games/gomoku/envs/gomoku_rule_bot_v0.py @@ -1,26 +1,18 @@ import copy import logging -from random import random +from collections import namedtuple +from typing import List, Dict, Any, Tuple, Union import numpy as np -from ding.policy.base_policy import Policy -from collections import namedtuple -from typing import Optional, List, Dict, Any, Tuple, Union import torch -import copy -import numpy as np -from ding.torch_utils import to_device -from ding.rl_utils import get_train_sample +from ding.policy.base_policy import Policy from ding.utils import POLICY_REGISTRY -from ding.utils.data import default_collate, default_decollate + from zoo.board_games.gomoku.envs.utils import check_action_to_special_connect4_case1, \ check_action_to_special_connect4_case2, \ check_action_to_connect4 - - - @POLICY_REGISTRY.register('gomoku_bot_v0') class GomokuBotV0(Policy): """ @@ -59,6 +51,8 @@ def rule_bot_v0(self, obs): - action (:obj:`int`): the expert action to take in the current game state. """ board = obs['board'] + current_player_to_compute_bot_action = -1 if obs['to_play'] == 1 else 1 + assert self.board_size >= 5, "current rule_bot_v0 is only support self.board_size>=5!" # To easily calculate expert action, we convert the chessboard notation: # from player 1: 1, player 2: 2 @@ -114,7 +108,7 @@ def rule_bot_v0(self, obs): ) else: if zero_position_index.shape[0] == 2: - ind = random.choice(zero_position_index) + ind = np.random.choice(zero_position_index) elif zero_position_index.shape[0] == 1: ind = zero_position_index[0] # convert ind to action @@ -132,17 +126,17 @@ def rule_bot_v0(self, obs): action_to_special_connect4_case2 = action if check_action_to_connect4(shfit_tmp_board[i, :]): action_to_connect4 = action - if (self.current_player_to_compute_bot_action * sum(shfit_tmp_board[i, :]) > 0) and abs(sum( + if (current_player_to_compute_bot_action * sum(shfit_tmp_board[i, :]) > 0) and abs(sum( shfit_tmp_board[i, :])) == size_of_board_template - 1: # immediately take the action that will lead a connect5 of current player's pieces return action - if (self.current_player_to_compute_bot_action * sum(shfit_tmp_board[i, :]) < 0) and abs(sum( + if (current_player_to_compute_bot_action * sum(shfit_tmp_board[i, :]) < 0) and abs(sum( shfit_tmp_board[i, :])) == size_of_board_template - 1: # memory the action that will lead a connect5 of opponent player's pieces, to avoid the forget action_block_opponent_to_connect5 = action if abs(sum(shfit_tmp_board[:, i])) >= min_to_connect: - # if i-th vertical has three same pieces and two empty position, or four same pieces and one opponent piece. + # if i-th vertical has three same pieces and two empty positions, or four same pieces and one opponent piece. # e.g., case1: .xxx. , case2: oxxxx # find the index in the i-th vertical line @@ -153,7 +147,7 @@ def rule_bot_v0(self, obs): ) else: if zero_position_index.shape[0] == 2: - ind = random.choice(zero_position_index) + ind = np.random.choice(zero_position_index) elif zero_position_index.shape[0] == 1: ind = zero_position_index[0] @@ -172,22 +166,22 @@ def rule_bot_v0(self, obs): action_to_special_connect4_case2 = action if check_action_to_connect4(shfit_tmp_board[:, i]): action_to_connect4 = action - if (self.current_player_to_compute_bot_action * sum(shfit_tmp_board[:, i]) > 0) and abs(sum( + if (current_player_to_compute_bot_action * sum(shfit_tmp_board[:, i]) > 0) and abs(sum( shfit_tmp_board[:, i])) == size_of_board_template - 1: # immediately take the action that will lead a connect5 of current player's pieces return action - if (self.current_player_to_compute_bot_action * sum(shfit_tmp_board[:, i]) < 0) and abs(sum( + if (current_player_to_compute_bot_action * sum(shfit_tmp_board[:, i]) < 0) and abs(sum( shfit_tmp_board[:, i])) == size_of_board_template - 1: - # memory the action that will lead a connect5 of opponent player's pieces, to avoid the forget + # memory the action that will lead a connect5 of opponent player's pieces, to avoid the forgetting action_block_opponent_to_connect5 = action # Diagonal checks diag = shfit_tmp_board.diagonal() anti_diag = np.fliplr(shfit_tmp_board).diagonal() if abs(sum(diag)) >= min_to_connect: - # if diagonal has three same pieces and two empty position, or four same pieces and one opponent piece. + # if diagonal has three same pieces and two empty positions, or four same pieces and one opponent piece. # e.g., case1: .xxx. , case2: oxxxx - # find the index in the diag vector + # finds the index in the diag vector zero_position_index = np.where(diag == 0)[0] if zero_position_index.shape[0] == 0: @@ -195,7 +189,7 @@ def rule_bot_v0(self, obs): 'there is no empty position in this searched five positions, continue to search...') else: if zero_position_index.shape[0] == 2: - ind = random.choice(zero_position_index) + ind = np.random.choice(zero_position_index) elif zero_position_index.shape[0] == 1: ind = zero_position_index[0] @@ -214,11 +208,11 @@ def rule_bot_v0(self, obs): action_to_special_connect4_case2 = action if check_action_to_connect4(diag): action_to_connect4 = action - if self.current_player_to_compute_bot_action * sum(diag) > 0 and abs( + if current_player_to_compute_bot_action * sum(diag) > 0 and abs( sum(diag)) == size_of_board_template - 1: # immediately take the action that will lead a connect5 of current player's pieces return action - if self.current_player_to_compute_bot_action * sum(diag) < 0 and abs( + if current_player_to_compute_bot_action * sum(diag) < 0 and abs( sum(diag)) == size_of_board_template - 1: # memory the action that will lead a connect5 of opponent player's pieces, to avoid the forget action_block_opponent_to_connect5 = action @@ -234,7 +228,7 @@ def rule_bot_v0(self, obs): 'there is no empty position in this searched five positions, continue to search...') else: if zero_position_index.shape[0] == 2: - ind = random.choice(zero_position_index) + ind = np.random.choice(zero_position_index) elif zero_position_index.shape[0] == 1: ind = zero_position_index[0] # convert ind to action @@ -252,11 +246,11 @@ def rule_bot_v0(self, obs): action_to_special_connect4_case2 = action if check_action_to_connect4(anti_diag): action_to_connect4 = action - if self.current_player_to_compute_bot_action * sum(anti_diag) > 0 and abs( + if current_player_to_compute_bot_action * sum(anti_diag) > 0 and abs( sum(anti_diag)) == size_of_board_template - 1: # immediately take the action that will lead a connect5 of current player's pieces return action - if self.current_player_to_compute_bot_action * sum(anti_diag) < 0 and abs( + if current_player_to_compute_bot_action * sum(anti_diag) < 0 and abs( sum(anti_diag)) == size_of_board_template - 1: # memory the action that will lead a connect5 of opponent player's pieces, to avoid the forget action_block_opponent_to_connect5 = action @@ -277,7 +271,7 @@ def _init_learn(self) -> None: def _init_collect(self) -> None: self.board_size = self._cfg.board_size - pass + self.check_action_to_connect4_in_bot_v0 = False def _init_eval(self) -> None: pass diff --git a/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py b/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py index 0ca76dfd3..0c54a806b 100644 --- a/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py +++ b/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py @@ -72,7 +72,7 @@ # log_freq=2, # debug player_category=['tictactoe'], # path to save policy of league player, user can specify this field - path_policy=f"tictactoe_alphazero_league_policy_ckpt_sp-{sp_prob}", + path_policy=f"data_az_ptree_league/tictactoe_alphazero_league_policy_ckpt_sp-{sp_prob}", active_players=dict(main_player=1, ), main_player=dict( # An active player will be considered trained enough for snapshot after two phase steps. diff --git a/zoo/board_games/tictactoe/envs/rule_bot_v0.py b/zoo/board_games/tictactoe/envs/tictactoe_rule_bot_v0.py similarity index 97% rename from zoo/board_games/tictactoe/envs/rule_bot_v0.py rename to zoo/board_games/tictactoe/envs/tictactoe_rule_bot_v0.py index 7de8ac7cc..2ffe131d7 100644 --- a/zoo/board_games/tictactoe/envs/rule_bot_v0.py +++ b/zoo/board_games/tictactoe/envs/tictactoe_rule_bot_v0.py @@ -42,7 +42,7 @@ def rule_bot_v0(self, obs): """ Overview: Hard coded expert agent for tictactoe env. - First random sample a action from legal_actions, then take the action that will lead a connect3 of current player's pieces. + First random sample an action from legal_actions, then take the action that will lead a connect3 of current player's pieces. Returns: - action (:obj:`int`): the expert action to take in the current game state. """ From 71d6eac01bc97f4e868b8ded8d25d2ce796111a3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Wed, 17 May 2023 02:08:01 +0800 Subject: [PATCH 06/34] feature(pu): add snapshot_the_player_in_iter_zero and one_phase_step option, fix norm_type in az prediction net, fix temperature in az_league --- lzero/entry/train_alphazero.py | 2 - lzero/entry/train_alphazero_league.py | 43 ++++++++++++++--- lzero/model/alphazero_model.py | 4 +- lzero/policy/alphazero.py | 2 + lzero/worker/battle_alphazero_collector.py | 4 +- .../config/gomoku_alphazero_league_config.py | 16 ++++--- .../tictactoe_alphazero_league_config.py | 47 +++++++++++-------- 7 files changed, 78 insertions(+), 40 deletions(-) diff --git a/lzero/entry/train_alphazero.py b/lzero/entry/train_alphazero.py index 6744ef871..1b7f24c8c 100644 --- a/lzero/entry/train_alphazero.py +++ b/lzero/entry/train_alphazero.py @@ -12,7 +12,6 @@ from ding.worker import BaseLearner, create_buffer from tensorboardX import SummaryWriter -from lzero.entry.utils import log_buffer_memory_usage from lzero.policy import visit_count_temperature from lzero.worker import AlphaZeroCollector, AlphaZeroEvaluator @@ -94,7 +93,6 @@ def train_alphazero( # Learner's before_run hook. learner.call_hook('before_run') while True: - log_buffer_memory_usage(learner.train_iter, replay_buffer, tb_logger) collect_kwargs = {} # set temperature for visit count distributions according to the train_iter, # please refer to Appendix D in MuZero paper for details. diff --git a/lzero/entry/train_alphazero_league.py b/lzero/entry/train_alphazero_league.py index c965c1c83..9f3af16f3 100644 --- a/lzero/entry/train_alphazero_league.py +++ b/lzero/entry/train_alphazero_league.py @@ -3,6 +3,7 @@ import os import shutil from functools import partial +from typing import Optional import torch from ding.config import compile_config @@ -18,6 +19,7 @@ from lzero.policy.alphazero import AlphaZeroPolicy from lzero.worker import AlphaZeroEvaluator from lzero.worker import BattleAlphaZeroCollector +from lzero.policy import visit_count_temperature def win_loss_draw(episode_info): @@ -79,7 +81,19 @@ def save_checkpoint(src_checkpoint_path: str, dst_checkpoint_path: str) -> None: shutil.copy(src_checkpoint_path, dst_checkpoint_path) -def train_alphazero_league(cfg, Env, seed=0): +def train_alphazero_league(cfg, Env, seed=0, max_train_iter: Optional[int] = int(1e10), max_env_step: Optional[int] = int(1e10)) -> None: + """ + Overview: + Train alphazero league + Arguments: + - cfg (:obj:`EasyDict`): Config dict + - Env (:obj:`BaseEnv`): Env class + - seed (:obj:`int`): Random seed + - max_train_iter (:obj:`Optional[int]`): Maximum policy update iterations in training. + - max_env_step (:obj:`Optional[int]`): Maximum collected environment interaction steps. + Returns: + - None + """ # prepare config cfg = compile_config( cfg, @@ -166,10 +180,12 @@ def load_checkpoint_fn(player_id: str, ckpt_path: str): policies[player_id].learn_mode.load_state_dict(state_dict) league.load_checkpoint = load_checkpoint_fn - # snapshot the initial player as the first historical player - for player_id, player_ckpt_path in zip(league.active_players_ids, league.active_players_ckpts): - torch.save(policies[player_id].collect_mode.state_dict(), player_ckpt_path) - league.judge_snapshot(player_id, force=True) + + if cfg.policy.league.snapshot_the_player_in_iter_zero: + # snapshot the initial player as the first historical player + for player_id, player_ckpt_path in zip(league.active_players_ids, league.active_players_ckpts): + torch.save(policies[player_id].collect_mode.state_dict(), player_ckpt_path) + league.judge_snapshot(player_id, force=True) set_pkg_seed(seed, use_cuda=cfg.policy.cuda) league_iter = 0 @@ -208,8 +224,18 @@ def load_checkpoint_fn(player_id: str, ckpt_path: str): collector.reset_policy([policies[player_id].collect_mode, opponent_policy]) + collect_kwargs = {} + # set temperature for visit count distributions according to the train_iter, + # please refer to Appendix D in MuZero paper for details. + collect_kwargs['temperature'] = visit_count_temperature( + cfg.policy.manual_temperature_decay, + cfg.policy.fixed_temperature_value, + cfg.policy.threshold_training_steps_for_final_temperature, + trained_steps=learner.train_iter + ) + new_data, episode_info = collector.collect( - train_iter=learner.train_iter, n_episode=cfg.policy.n_episode + train_iter=learner.train_iter, n_episode=cfg.policy.n_episode, policy_kwargs=collect_kwargs ) # TODO(pu): new_data[1] new_data = sum(new_data[0], []) @@ -246,10 +272,13 @@ def load_checkpoint_fn(player_id: str, ckpt_path: str): } league.finish_job(job_finish_info, league_iter) - if league_iter % cfg.policy.league.log_freq == 0: + if league_iter % cfg.policy.league.log_freq_for_payoff_rank == 0: payoff_string = repr(league.payoff) rank_string = league.player_rank(string=True) tb_logger.add_text('payoff_step', payoff_string, main_collector.envstep) tb_logger.add_text('rank_step', rank_string, main_collector.envstep) league_iter += 1 + + if main_collector.envstep >= max_env_step or main_learner.train_iter >= max_train_iter: + break diff --git a/lzero/model/alphazero_model.py b/lzero/model/alphazero_model.py index 27e8eb26d..b916be093 100644 --- a/lzero/model/alphazero_model.py +++ b/lzero/model/alphazero_model.py @@ -232,7 +232,7 @@ def __init__( out_channels=output_support_size, layer_num=len(fc_value_layers) + 1, activation=activation, - norm_type='BN', + norm_type='LN', output_activation=False, output_norm=False, last_linear_layer_init_zero=last_linear_layer_init_zero @@ -243,7 +243,7 @@ def __init__( out_channels=action_space_size, layer_num=len(fc_policy_layers) + 1, activation=activation, - norm_type='BN', + norm_type='LN', output_activation=False, output_norm=False, last_linear_layer_init_zero=last_linear_layer_init_zero diff --git a/lzero/policy/alphazero.py b/lzero/policy/alphazero.py index 6abaf4944..7836e2719 100644 --- a/lzero/policy/alphazero.py +++ b/lzero/policy/alphazero.py @@ -23,6 +23,8 @@ class AlphaZeroPolicy(Policy): # The default_config for AlphaZero policy. config = dict( + # (str) The type of policy, as the key of the policy registry. + type='alphazero', # (bool) Whether to use torch.compile method to speed up our model, which required torch>=2.0. torch_compile=False, # (bool) Whether to use TF32 for our model. diff --git a/lzero/worker/battle_alphazero_collector.py b/lzero/worker/battle_alphazero_collector.py index 370c05c3e..6a7e328be 100644 --- a/lzero/worker/battle_alphazero_collector.py +++ b/lzero/worker/battle_alphazero_collector.py @@ -213,9 +213,7 @@ def collect(self, assert n_episode >= self._env_num, "Please make sure n_episode >= env_num" if policy_kwargs is None: policy_kwargs = {} - # temperature = policy_kwargs['temperature'] - # TODO(pu) - temperature = 1. + temperature = policy_kwargs['temperature'] collected_episode = 0 return_data = [[] for _ in range(2)] diff --git a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py index 191846b46..bd44177bd 100644 --- a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py +++ b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py @@ -12,8 +12,10 @@ num_simulations = 50 update_per_collect = 50 batch_size = 256 -max_env_step = int(1e6) +max_env_step = int(2e6) sp_prob = 0. # TODO(pu): 0, 0.8, 1 +snapshot_the_player_in_iter_zero = False +one_phase_step = int(1e5) # collector_env_num = 2 # n_episode = 2 @@ -28,7 +30,7 @@ # ============================================================== gomoku_alphazero_league_config = dict( - exp_name=f"data_az_ptree_league/gomoku_alphazero_league_sp-{sp_prob}_seed0", + exp_name=f"data_az_ptree_league/gomoku_alphazero_league_sp-{sp_prob}_iter-zero-init-{snapshot_the_player_in_iter_zero}_phase-step-{one_phase_step}_seed0", env=dict( env_name="Gomoku", board_size=board_size, @@ -72,15 +74,15 @@ collector_env_num=collector_env_num, evaluator_env_num=evaluator_env_num, league=dict( - log_freq=50, + log_freq_for_payoff_rank=50, # log_freq=2, # debug player_category=['gomoku'], # path to save policy of league player, user can specify this field - path_policy=f"data_az_ptree_league/gomoku_alphazero_league_policy_ckpt_sp-{sp_prob}", + path_policy=f"data_az_ptree_league/gomoku_alphazero_league_sp-{sp_prob}_iter-zero-init-{snapshot_the_player_in_iter_zero}_phase-step-{one_phase_step}_policy_ckpt_seed0", active_players=dict(main_player=1, ), main_player=dict( # An active player will be considered trained enough for snapshot after two phase steps. - one_phase_step=20000, + one_phase_step=one_phase_step, # A namedtuple of probabilities of selecting different opponent branch. # branch_probs=dict(pfsp=0.2, sp=0.8), branch_probs=dict(pfsp=1 - sp_prob, sp=sp_prob), @@ -93,6 +95,8 @@ use_pretrain_init_historical=False, # "use_bot_init_historica" means whether to use bot as an init historical player use_bot_init_historical=True, + # "snapshot_the_player_in_iter_zero" means whether to snapshot the player in iter zero as historical_player. + snapshot_the_player_in_iter_zero=snapshot_the_player_in_iter_zero, payoff=dict( type='battle', decay=0.99, @@ -138,4 +142,4 @@ if __name__ == "__main__": from lzero.entry import train_alphazero_league from zoo.board_games.gomoku.envs.gomoku_env import GomokuEnv - train_alphazero_league(main_config, GomokuEnv) \ No newline at end of file + train_alphazero_league(main_config, GomokuEnv, max_env_step=max_env_step) \ No newline at end of file diff --git a/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py b/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py index 0c54a806b..0ed234612 100644 --- a/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py +++ b/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py @@ -3,29 +3,34 @@ # ============================================================== # begin of the most frequently changed config specified by the user # ============================================================== -collector_env_num = 8 -n_episode = 8 -evaluator_env_num = 5 -num_simulations = 25 -update_per_collect = 50 -batch_size = 256 -max_env_step = int(2e5) -sp_prob = 0. # TODO(pu): 0, 0.8, 1 +# collector_env_num = 8 +# n_episode = 8 +# evaluator_env_num = 5 +# num_simulations = 25 +# update_per_collect = 50 +# batch_size = 256 +# max_env_step = int(5e5) +# sp_prob = 0 # TODO(pu): 0, 0.8, 1 +# snapshot_the_player_in_iter_zero = False +# one_phase_step = int(1e5) +collector_env_num = 2 +n_episode = 2 +evaluator_env_num = 2 +num_simulations = 2 +update_per_collect = 5 +batch_size = 2 +max_env_step = int(2e5) +sp_prob = 0 # TODO(pu): 0, 0.8, 1 +snapshot_the_player_in_iter_zero = False +one_phase_step = int(2e5) -# collector_env_num = 2 -# n_episode = 2 -# evaluator_env_num = 2 -# num_simulations = 2 -# update_per_collect = 5 -# batch_size = 2 -# max_env_step = int(2e5) # ============================================================== # end of the most frequently changed config specified by the user # ============================================================== tictactoe_alphazero_league_config = dict( - exp_name=f"data_az_ptree_league/tictactoe_alphazero_league_sp-{sp_prob}_seed0", + exp_name=f"data_az_ptree_league/tictactoe_alphazero_league_sp-{sp_prob}_iter-zero-init-{snapshot_the_player_in_iter_zero}_phase-step-{one_phase_step}_seed0", env=dict( board_size=3, battle_mode='self_play_mode', @@ -68,15 +73,15 @@ collector_env_num=collector_env_num, evaluator_env_num=evaluator_env_num, league=dict( - log_freq=50, + log_freq_for_payoff_rank=50, # log_freq=2, # debug player_category=['tictactoe'], # path to save policy of league player, user can specify this field - path_policy=f"data_az_ptree_league/tictactoe_alphazero_league_policy_ckpt_sp-{sp_prob}", + path_policy=f"data_az_ptree_league/tictactoe_alphazero_league_sp-{sp_prob}_iter-zero-init-{snapshot_the_player_in_iter_zero}_phase-step-{one_phase_step}_policy_ckpt_seed0", active_players=dict(main_player=1, ), main_player=dict( # An active player will be considered trained enough for snapshot after two phase steps. - one_phase_step=20000, + one_phase_step=one_phase_step, # A namedtuple of probabilities of selecting different opponent branch. # branch_probs=dict(pfsp=0.2, sp=0.8), branch_probs=dict(pfsp=1-sp_prob, sp=sp_prob), @@ -89,6 +94,8 @@ use_pretrain_init_historical=False, # "use_bot_init_historica" means whether to use bot as an init historical player use_bot_init_historical=True, + # "snapshot_the_player_in_iter_zero" means whether to snapshot the player in iter zero as historical_player. + snapshot_the_player_in_iter_zero=snapshot_the_player_in_iter_zero, payoff=dict( type='battle', decay=0.99, @@ -134,4 +141,4 @@ if __name__ == "__main__": from lzero.entry import train_alphazero_league from zoo.board_games.tictactoe.envs.tictactoe_env import TicTacToeEnv - train_alphazero_league(main_config, TicTacToeEnv) + train_alphazero_league(main_config, TicTacToeEnv, max_env_step=max_env_step) From 52b5d8cab9c4d187f045c22e22fc0391f160aee5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Wed, 17 May 2023 16:18:58 +0800 Subject: [PATCH 07/34] fix(pu): only use the main_player transitions to tran main_player, polish league config --- lzero/entry/train_alphazero_league.py | 17 +++++- lzero/mcts/ptree/ptree_az.py | 2 +- lzero/worker/battle_alphazero_collector.py | 53 ++++++++++++------- .../gomoku_alphazero_bot_mode_config.py | 1 + .../config/gomoku_alphazero_league_config.py | 6 +-- .../config/gomoku_alphazero_sp_mode_config.py | 1 + .../tictactoe_alphazero_bot_mode_config.py | 1 + .../tictactoe_alphazero_league_config.py | 41 +++++++------- .../tictactoe_alphazero_sp_mode_config.py | 1 + 9 files changed, 78 insertions(+), 45 deletions(-) diff --git a/lzero/entry/train_alphazero_league.py b/lzero/entry/train_alphazero_league.py index 9f3af16f3..20da87168 100644 --- a/lzero/entry/train_alphazero_league.py +++ b/lzero/entry/train_alphazero_league.py @@ -217,12 +217,27 @@ def load_checkpoint_fn(player_id: str, ckpt_path: str): opponent_policy = policies['historical'].collect_mode opponent_path = job['checkpoint_path'][1] opponent_policy.load_state_dict(torch.load(opponent_path, map_location='cpu')) + opponent_policy_info = { + 'policy': opponent_policy, + 'policy_id': opponent_player_id, + 'policy_type': 'historical' + } elif 'bot' in opponent_player_id: opponent_policy = policies['bot'].collect_mode + opponent_policy_info = { + 'policy': opponent_policy, + 'policy_id': opponent_player_id, + 'policy_type': 'bot' + } else: opponent_policy = policies[opponent_player_id].collect_mode + opponent_policy_info = { + 'policy': opponent_policy, + 'policy_id': opponent_player_id, + 'policy_type': 'main' + } - collector.reset_policy([policies[player_id].collect_mode, opponent_policy]) + collector.reset_policy([policies[player_id].collect_mode, opponent_policy_info]) collect_kwargs = {} # set temperature for visit count distributions according to the train_iter, diff --git a/lzero/mcts/ptree/ptree_az.py b/lzero/mcts/ptree/ptree_az.py index 44d91573d..0371bd751 100644 --- a/lzero/mcts/ptree/ptree_az.py +++ b/lzero/mcts/ptree/ptree_az.py @@ -123,7 +123,7 @@ def get_next_action( self, simulate_env: Type[BaseEnv], policy_forward_fn: Callable, - temperature: int = 1.0, + temperature: float = 1.0, sample: bool = True ) -> Tuple[int, List[float]]: """ diff --git a/lzero/worker/battle_alphazero_collector.py b/lzero/worker/battle_alphazero_collector.py index 6a7e328be..06053f506 100644 --- a/lzero/worker/battle_alphazero_collector.py +++ b/lzero/worker/battle_alphazero_collector.py @@ -105,7 +105,10 @@ def reset_policy(self, _policy: Optional[List[namedtuple]] = None) -> None: ) ) for p in self._policy: - p.reset() + if isinstance(p, dict): + p['policy'].reset() + else: + p.reset() def reset(self, _policy: Optional[List[namedtuple]] = None, _env: Optional[BaseEnvManager] = None) -> None: """ @@ -221,6 +224,7 @@ def collect(self, ready_env_id = set() remain_episode = n_episode + while True: # for policy_id, policy in enumerate(self._policy): with self._timer: @@ -260,13 +264,21 @@ def collect(self, ready_env_id_player_2.append(k) if len(ready_env_id_player_1) > 0: - policy_output_player_1 = self._policy[0].forward(simulation_envs_player_1, obs_player_1, - temperature) + if isinstance(self._policy[0], dict): + policy_output_player_1 = self._policy[0]['policy'].forward(simulation_envs_player_1, obs_player_1, + temperature) + else: + policy_output_player_1 = self._policy[0].forward(simulation_envs_player_1, obs_player_1, + temperature) else: policy_output_player_1 = {} if len(ready_env_id_player_2) > 0: - policy_output_player_2 = self._policy[1].forward(simulation_envs_player_2, obs_player_2, - temperature) + if isinstance(self._policy[1], dict): + policy_output_player_2 = self._policy[1]['policy'].forward(simulation_envs_player_2, obs_player_2, + temperature) + else: + policy_output_player_2 = self._policy[1].forward(simulation_envs_player_2, obs_player_2, + temperature) else: policy_output_player_2 = {} @@ -297,20 +309,16 @@ def collect(self, elif env_id in ready_env_id_player_2: policy_id = 1 with self._timer: - # for policy_id, policy in enumerate(self._policy): - # policy_timestep_data = [d[policy_id] if not isinstance(d, bool) else d for d in timestep] - # policy_timestep = type(timestep)(*policy_timestep_data) - # transition = self._policy[policy_id].process_transition( - # self._obs_pool[env_id][policy_id], self._policy_output_pool[env_id][policy_id], - # policy_timestep - # ) - if isinstance(self._policy[policy_id].forward.__self__, TictactoeBotV0) or isinstance(self._policy[policy_id].forward.__self__, GomokuBotV0): - # bot policy does not need to process transition - transition = self._policy[0].process_transition( - self._obs_pool[env_id], self._policy_output_pool[env_id], - timestep - ) - transition['collect_iter'] = train_iter + if isinstance(self._policy[policy_id], dict): + if self._policy[policy_id]['policy_type'] in ['bot', 'historical']: + # The data produced by bot and historical policy is not used for training. + pass + elif self._policy[policy_id]['policy_type'] == 'main': + transition = self._policy[policy_id]['policy'].process_transition( + self._obs_pool[env_id], self._policy_output_pool[env_id], + timestep + ) + transition['collect_iter'] = train_iter else: transition = self._policy[policy_id].process_transition( self._obs_pool[env_id], self._policy_output_pool[env_id], @@ -345,7 +353,12 @@ def collect(self, collected_episode += 1 self._episode_info.append(info) for i, p in enumerate(self._policy): - p.reset([env_id]) + # p.reset([env_id]) + if isinstance(p, dict): + p['policy'].reset([env_id]) + else: + p.reset([env_id]) + self._reset_stat(env_id) ready_env_id.remove(env_id) for policy_id in range(2): diff --git a/zoo/board_games/gomoku/config/gomoku_alphazero_bot_mode_config.py b/zoo/board_games/gomoku/config/gomoku_alphazero_bot_mode_config.py index 5aa9c4abe..b9761d397 100644 --- a/zoo/board_games/gomoku/config/gomoku_alphazero_bot_mode_config.py +++ b/zoo/board_games/gomoku/config/gomoku_alphazero_bot_mode_config.py @@ -19,6 +19,7 @@ exp_name= f'data_az_ptree/gomoku_alphazero_bot-mode_rand{prob_random_action_in_bot}_ns{num_simulations}_upc{update_per_collect}_seed0', env=dict( + stop_value=2, board_size=board_size, battle_mode='play_with_bot_mode', bot_action_type='v0', diff --git a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py index bd44177bd..41f466e5f 100644 --- a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py +++ b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py @@ -12,8 +12,8 @@ num_simulations = 50 update_per_collect = 50 batch_size = 256 -max_env_step = int(2e6) -sp_prob = 0. # TODO(pu): 0, 0.8, 1 +max_env_step = int(1e6) +sp_prob = 0.5 # TODO(pu): 0, 0.8, 1 snapshot_the_player_in_iter_zero = False one_phase_step = int(1e5) @@ -32,6 +32,7 @@ gomoku_alphazero_league_config = dict( exp_name=f"data_az_ptree_league/gomoku_alphazero_league_sp-{sp_prob}_iter-zero-init-{snapshot_the_player_in_iter_zero}_phase-step-{one_phase_step}_seed0", env=dict( + stop_value=2, env_name="Gomoku", board_size=board_size, battle_mode='self_play_mode', @@ -42,7 +43,6 @@ bot_action_type='v0', # {'v0', 'alpha_beta_pruning'} prob_random_action_in_bot=prob_random_action_in_bot, check_action_to_connect4_in_bot_v0=False, - stop_value=1, collector_env_num=collector_env_num, evaluator_env_num=evaluator_env_num, n_evaluator_episode=evaluator_env_num, diff --git a/zoo/board_games/gomoku/config/gomoku_alphazero_sp_mode_config.py b/zoo/board_games/gomoku/config/gomoku_alphazero_sp_mode_config.py index 2ca4da3ad..227af4275 100644 --- a/zoo/board_games/gomoku/config/gomoku_alphazero_sp_mode_config.py +++ b/zoo/board_games/gomoku/config/gomoku_alphazero_sp_mode_config.py @@ -19,6 +19,7 @@ exp_name= f'data_az_ptree/gomoku_alphazero_sp-mode_rand{prob_random_action_in_bot}_ns{num_simulations}_upc{update_per_collect}_seed0', env=dict( + stop_value=2, board_size=board_size, battle_mode='self_play_mode', bot_action_type='v0', diff --git a/zoo/board_games/tictactoe/config/tictactoe_alphazero_bot_mode_config.py b/zoo/board_games/tictactoe/config/tictactoe_alphazero_bot_mode_config.py index 06c29561a..f5fee9b78 100644 --- a/zoo/board_games/tictactoe/config/tictactoe_alphazero_bot_mode_config.py +++ b/zoo/board_games/tictactoe/config/tictactoe_alphazero_bot_mode_config.py @@ -17,6 +17,7 @@ tictactoe_alphazero_config = dict( exp_name=f'data_az_ptree/tictactoe_alphazero_bot-mode_ns{num_simulations}_upc{update_per_collect}_seed0', env=dict( + stop_value=2, board_size=3, battle_mode='play_with_bot_mode', channel_last=False, # NOTE diff --git a/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py b/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py index 0ed234612..8506a07a4 100644 --- a/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py +++ b/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py @@ -3,27 +3,27 @@ # ============================================================== # begin of the most frequently changed config specified by the user # ============================================================== -# collector_env_num = 8 -# n_episode = 8 -# evaluator_env_num = 5 -# num_simulations = 25 -# update_per_collect = 50 -# batch_size = 256 -# max_env_step = int(5e5) -# sp_prob = 0 # TODO(pu): 0, 0.8, 1 -# snapshot_the_player_in_iter_zero = False -# one_phase_step = int(1e5) - -collector_env_num = 2 -n_episode = 2 -evaluator_env_num = 2 -num_simulations = 2 -update_per_collect = 5 -batch_size = 2 +collector_env_num = 8 +n_episode = 8 +evaluator_env_num = 5 +num_simulations = 25 +update_per_collect = 50 +batch_size = 256 max_env_step = int(2e5) -sp_prob = 0 # TODO(pu): 0, 0.8, 1 +sp_prob = 0.5 # TODO(pu): 0, 0.8, 1 snapshot_the_player_in_iter_zero = False -one_phase_step = int(2e5) +one_phase_step = int(2e4) + +# collector_env_num = 2 +# n_episode = 2 +# evaluator_env_num = 2 +# num_simulations = 2 +# update_per_collect = 5 +# batch_size = 2 +# max_env_step = int(2e5) +# sp_prob = 0 # TODO(pu): 0, 0.8, 1 +# snapshot_the_player_in_iter_zero = False +# one_phase_step = int(5e4) # ============================================================== # end of the most frequently changed config specified by the user @@ -32,6 +32,7 @@ tictactoe_alphazero_league_config = dict( exp_name=f"data_az_ptree_league/tictactoe_alphazero_league_sp-{sp_prob}_iter-zero-init-{snapshot_the_player_in_iter_zero}_phase-step-{one_phase_step}_seed0", env=dict( + stop_value=2, board_size=3, battle_mode='self_play_mode', channel_last=False, # NOTE @@ -46,7 +47,6 @@ prob_random_agent=0, prob_expert_agent=0, scale=True, - stop_value=2, ), policy=dict( model=dict( @@ -98,6 +98,7 @@ snapshot_the_player_in_iter_zero=snapshot_the_player_in_iter_zero, payoff=dict( type='battle', + # ``_decay``` controls how past game info (win, draw, loss) decays. decay=0.99, min_win_rate_games=4, ), diff --git a/zoo/board_games/tictactoe/config/tictactoe_alphazero_sp_mode_config.py b/zoo/board_games/tictactoe/config/tictactoe_alphazero_sp_mode_config.py index a56c10bc9..dd73d5748 100644 --- a/zoo/board_games/tictactoe/config/tictactoe_alphazero_sp_mode_config.py +++ b/zoo/board_games/tictactoe/config/tictactoe_alphazero_sp_mode_config.py @@ -16,6 +16,7 @@ tictactoe_alphazero_config = dict( exp_name='data_az_ptree/tictactoe_sp-mode_alphazero_seed0', env=dict( + stop_value=2, board_size=3, battle_mode='self_play_mode', channel_last=False, # NOTE From 31376c6485179fcdd8c7a5dfe86f555071e03755 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Wed, 17 May 2023 18:36:15 +0800 Subject: [PATCH 08/34] fix(pu): fix save transitions in battle_alphazero_collector --- lzero/entry/train_alphazero_league.py | 3 +-- lzero/worker/battle_alphazero_collector.py | 21 +++++++++++-------- .../config/gomoku_alphazero_league_config.py | 4 +++- .../tictactoe_alphazero_league_config.py | 2 +- 4 files changed, 17 insertions(+), 13 deletions(-) diff --git a/lzero/entry/train_alphazero_league.py b/lzero/entry/train_alphazero_league.py index 20da87168..d0ec8f801 100644 --- a/lzero/entry/train_alphazero_league.py +++ b/lzero/entry/train_alphazero_league.py @@ -252,8 +252,7 @@ def load_checkpoint_fn(player_id: str, ckpt_path: str): new_data, episode_info = collector.collect( train_iter=learner.train_iter, n_episode=cfg.policy.n_episode, policy_kwargs=collect_kwargs ) - # TODO(pu): new_data[1] - new_data = sum(new_data[0], []) + new_data = sum(new_data[0], new_data[1]) replay_buffer.push(new_data, cur_collector_envstep=collector.envstep) # Learn policy from collected data for i in range(cfg.policy.update_per_collect): diff --git a/lzero/worker/battle_alphazero_collector.py b/lzero/worker/battle_alphazero_collector.py index 06053f506..35f888284 100644 --- a/lzero/worker/battle_alphazero_collector.py +++ b/lzero/worker/battle_alphazero_collector.py @@ -319,24 +319,27 @@ def collect(self, timestep ) transition['collect_iter'] = train_iter + self._traj_buffer[env_id][policy_id].append(transition) else: transition = self._policy[policy_id].process_transition( self._obs_pool[env_id], self._policy_output_pool[env_id], timestep ) transition['collect_iter'] = train_iter + self._traj_buffer[env_id][policy_id].append(transition) - self._traj_buffer[env_id][policy_id].append(transition) # prepare data if timestep.done: - transitions = to_tensor_transitions( - self._traj_buffer[env_id][policy_id], not self._deepcopy_obs - ) - # reward_shaping - transitions = self.reward_shaping(transitions, timestep.info['eval_episode_return']) - - return_data[policy_id].append(transitions) - self._traj_buffer[env_id][policy_id].clear() + for policy_id in range(2): + if len(self._traj_buffer[env_id][policy_id]) > 0: + transitions = to_tensor_transitions( + self._traj_buffer[env_id][policy_id], not self._deepcopy_obs + ) + # reward_shaping + transitions = self.reward_shaping(transitions, timestep.info['eval_episode_return']) + + return_data[policy_id].append(transitions) + self._traj_buffer[env_id][policy_id].clear() self._env_info[env_id]['time'] += self._timer.value + interaction_duration diff --git a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py index 41f466e5f..bc7e00cb1 100644 --- a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py +++ b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py @@ -13,7 +13,7 @@ update_per_collect = 50 batch_size = 256 max_env_step = int(1e6) -sp_prob = 0.5 # TODO(pu): 0, 0.8, 1 +sp_prob = 0. # TODO(pu): 0, 0.8, 1 snapshot_the_player_in_iter_zero = False one_phase_step = int(1e5) @@ -25,6 +25,8 @@ # batch_size = 2 # max_env_step = int(2e5) # sp_prob = 0. +# snapshot_the_player_in_iter_zero = False +# one_phase_step = int(1e6) # ============================================================== # end of the most frequently changed config specified by the user # ============================================================== diff --git a/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py b/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py index 8506a07a4..867847038 100644 --- a/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py +++ b/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py @@ -10,7 +10,7 @@ update_per_collect = 50 batch_size = 256 max_env_step = int(2e5) -sp_prob = 0.5 # TODO(pu): 0, 0.8, 1 +sp_prob = 0. # TODO(pu): 0, 0.8, 1 snapshot_the_player_in_iter_zero = False one_phase_step = int(2e4) From 0d38129a656da9e07e05eb1ff1e140d4ccfdc558 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Wed, 17 May 2023 20:54:04 +0800 Subject: [PATCH 09/34] fix(pu): fix new_data bug --- lzero/entry/train_alphazero_league.py | 8 ++++++-- .../gomoku/config/gomoku_alphazero_league_config.py | 2 +- .../config/tictactoe_alphazero_league_config.py | 10 +++++----- 3 files changed, 12 insertions(+), 8 deletions(-) diff --git a/lzero/entry/train_alphazero_league.py b/lzero/entry/train_alphazero_league.py index d0ec8f801..a4c2cb04b 100644 --- a/lzero/entry/train_alphazero_league.py +++ b/lzero/entry/train_alphazero_league.py @@ -81,7 +81,8 @@ def save_checkpoint(src_checkpoint_path: str, dst_checkpoint_path: str) -> None: shutil.copy(src_checkpoint_path, dst_checkpoint_path) -def train_alphazero_league(cfg, Env, seed=0, max_train_iter: Optional[int] = int(1e10), max_env_step: Optional[int] = int(1e10)) -> None: +def train_alphazero_league(cfg, Env, seed=0, max_train_iter: Optional[int] = int(1e10), + max_env_step: Optional[int] = int(1e10)) -> None: """ Overview: Train alphazero league @@ -252,7 +253,10 @@ def load_checkpoint_fn(player_id: str, ckpt_path: str): new_data, episode_info = collector.collect( train_iter=learner.train_iter, n_episode=cfg.policy.n_episode, policy_kwargs=collect_kwargs ) - new_data = sum(new_data[0], new_data[1]) + new_data_0 = sum(new_data[0], []) + new_data_1 = sum(new_data[1], []) + new_data = new_data_0 + new_data_1 + replay_buffer.push(new_data, cur_collector_envstep=collector.envstep) # Learn policy from collected data for i in range(cfg.policy.update_per_collect): diff --git a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py index bc7e00cb1..378d9a5e0 100644 --- a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py +++ b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py @@ -14,7 +14,7 @@ batch_size = 256 max_env_step = int(1e6) sp_prob = 0. # TODO(pu): 0, 0.8, 1 -snapshot_the_player_in_iter_zero = False +snapshot_the_player_in_iter_zero = True one_phase_step = int(1e5) # collector_env_num = 2 diff --git a/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py b/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py index 867847038..b3721f49d 100644 --- a/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py +++ b/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py @@ -10,8 +10,8 @@ update_per_collect = 50 batch_size = 256 max_env_step = int(2e5) -sp_prob = 0. # TODO(pu): 0, 0.8, 1 -snapshot_the_player_in_iter_zero = False +sp_prob = 0.5 # TODO(pu): 0, 0.8, 1 +snapshot_the_player_in_iter_zero = True one_phase_step = int(2e4) # collector_env_num = 2 @@ -21,9 +21,9 @@ # update_per_collect = 5 # batch_size = 2 # max_env_step = int(2e5) -# sp_prob = 0 # TODO(pu): 0, 0.8, 1 -# snapshot_the_player_in_iter_zero = False -# one_phase_step = int(5e4) +# sp_prob = 0.5 # TODO(pu): 0, 0.8, 1 +# snapshot_the_player_in_iter_zero = True +# one_phase_step = int(2) # ============================================================== # end of the most frequently changed config specified by the user From cc3be433973a15dc3eac342e44166164b99f6967 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Thu, 18 May 2023 16:38:41 +0800 Subject: [PATCH 10/34] polish(pu): polish league config --- .../gomoku/config/gomoku_alphazero_league_config.py | 8 ++++---- zoo/board_games/gomoku/envs/gomoku_env.py | 9 ++------- .../config/tictactoe_alphazero_eval_config.py | 11 ++++++++--- .../config/tictactoe_alphazero_league_config.py | 5 +++-- zoo/board_games/tictactoe/envs/tictactoe_env.py | 2 ++ 5 files changed, 19 insertions(+), 16 deletions(-) diff --git a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py index 378d9a5e0..37676b35f 100644 --- a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py +++ b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py @@ -13,9 +13,9 @@ update_per_collect = 50 batch_size = 256 max_env_step = int(1e6) -sp_prob = 0. # TODO(pu): 0, 0.8, 1 +sp_prob = 0. # TODO(pu): 0, 0.5, 1 snapshot_the_player_in_iter_zero = True -one_phase_step = int(1e5) +one_phase_step = int(2e4) # collector_env_num = 2 # n_episode = 2 @@ -25,8 +25,8 @@ # batch_size = 2 # max_env_step = int(2e5) # sp_prob = 0. -# snapshot_the_player_in_iter_zero = False -# one_phase_step = int(1e6) +# snapshot_the_player_in_iter_zero = True +# one_phase_step = int(5) # ============================================================== # end of the most frequently changed config specified by the user # ============================================================== diff --git a/zoo/board_games/gomoku/envs/gomoku_env.py b/zoo/board_games/gomoku/envs/gomoku_env.py index 684f861fa..bcb1a818e 100644 --- a/zoo/board_games/gomoku/envs/gomoku_env.py +++ b/zoo/board_games/gomoku/envs/gomoku_env.py @@ -200,11 +200,9 @@ def step(self, action): # player 1's turn timestep_player1 = self._player_step(action) - if self.agent_vs_human: - print('player 1 (agent): ' + self.action_to_string(action)) # Note: visualize - self.render() - if timestep_player1.done: + if self.agent_vs_human: + print(self.board) # in eval_mode, we set to_play as None/-1, because we don't consider the alternation between players timestep_player1.obs['to_play'] = -1 return timestep_player1 @@ -217,9 +215,6 @@ def step(self, action): # bot_action = self.random_action() timestep_player2 = self._player_step(bot_action) - if self.agent_vs_human: - print('player 2 (human): ' + self.action_to_string(bot_action)) # Note: visualize - self.render() # the eval_episode_return is calculated from Player 1's perspective timestep_player2.info['eval_episode_return'] = -timestep_player2.reward diff --git a/zoo/board_games/tictactoe/config/tictactoe_alphazero_eval_config.py b/zoo/board_games/tictactoe/config/tictactoe_alphazero_eval_config.py index 780cbe66f..cd9409f17 100644 --- a/zoo/board_games/tictactoe/config/tictactoe_alphazero_eval_config.py +++ b/zoo/board_games/tictactoe/config/tictactoe_alphazero_eval_config.py @@ -1,4 +1,6 @@ -from zoo.board_games.tictactoe.config.tictactoe_alphazero_bot_mode_config import main_config, create_config +# from zoo.board_games.tictactoe.config.tictactoe_alphazero_bot_mode_config import main_config, create_config +from zoo.board_games.tictactoe.config.tictactoe_alphazero_league_config import main_config, create_config + from lzero.entry import eval_alphazero import numpy as np @@ -8,11 +10,14 @@ point to the ckpt file of the pretrained model, and an absolute path is recommended. In LightZero, the path is usually something like ``exp_name/ckpt/ckpt_best.pth.tar``. """ - model_path = './ckpt/ckpt_best.pth.tar' + model_path = '/Users/puyuan/code/LightZero/sp_tb/ckpt_best_sp0.pth.tar' + seeds = [0] num_episodes_each_seed = 5 # If True, you can play with the agent. - main_config.env.agent_vs_human = False + # main_config.env.agent_vs_human = False + main_config.env.agent_vs_human = True + create_config.env_manager.type = 'base' main_config.env.evaluator_env_num = 1 main_config.env.n_evaluator_episode = 1 diff --git a/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py b/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py index b3721f49d..3b408aceb 100644 --- a/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py +++ b/zoo/board_games/tictactoe/config/tictactoe_alphazero_league_config.py @@ -10,7 +10,7 @@ update_per_collect = 50 batch_size = 256 max_env_step = int(2e5) -sp_prob = 0.5 # TODO(pu): 0, 0.8, 1 +sp_prob = 0.5 # TODO(pu): 0, 0.5, 1 snapshot_the_player_in_iter_zero = True one_phase_step = int(2e4) @@ -21,7 +21,7 @@ # update_per_collect = 5 # batch_size = 2 # max_env_step = int(2e5) -# sp_prob = 0.5 # TODO(pu): 0, 0.8, 1 +# sp_prob = 0.5 # TODO(pu): 0, 0.5, 1 # snapshot_the_player_in_iter_zero = True # one_phase_step = int(2) @@ -49,6 +49,7 @@ scale=True, ), policy=dict( + env_type='board_games', model=dict( observation_shape=(3, 3, 3), action_space_size=int(1 * 3 * 3), diff --git a/zoo/board_games/tictactoe/envs/tictactoe_env.py b/zoo/board_games/tictactoe/envs/tictactoe_env.py index b5afc9f14..a41b0dd82 100644 --- a/zoo/board_games/tictactoe/envs/tictactoe_env.py +++ b/zoo/board_games/tictactoe/envs/tictactoe_env.py @@ -205,6 +205,8 @@ def step(self, action): timestep_player1 = self._player_step(action) # self.env.render() if timestep_player1.done: + if self.agent_vs_human: + print(self.board) # NOTE: in eval_mode, we must set to_play as -1, because we don't consider the alternation between players. # And the to_play is used in MCTS. timestep_player1.obs['to_play'] = -1 From 36ecf62a5ff6ebe0c6a6e97f426f1c9004355edc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Thu, 25 May 2023 02:25:15 +0800 Subject: [PATCH 11/34] polish(pu): polish gomoku_alphazero_league_config --- .../config/gomoku_alphazero_bot_mode_config.py | 2 +- .../gomoku/config/gomoku_alphazero_eval_config.py | 12 +++++++++--- .../gomoku/config/gomoku_alphazero_league_config.py | 9 +++++---- .../gomoku/config/gomoku_alphazero_sp_mode_config.py | 2 +- .../gomoku/config/gomoku_muzero_bot_mode_config.py | 2 +- .../gomoku/config/gomoku_muzero_sp_mode_config.py | 2 +- zoo/board_games/gomoku/envs/gomoku_env.py | 3 ++- .../config/tictactoe_alphazero_eval_config.py | 2 +- 8 files changed, 21 insertions(+), 13 deletions(-) diff --git a/zoo/board_games/gomoku/config/gomoku_alphazero_bot_mode_config.py b/zoo/board_games/gomoku/config/gomoku_alphazero_bot_mode_config.py index b9761d397..c56b81115 100644 --- a/zoo/board_games/gomoku/config/gomoku_alphazero_bot_mode_config.py +++ b/zoo/board_games/gomoku/config/gomoku_alphazero_bot_mode_config.py @@ -8,7 +8,7 @@ n_episode = 32 evaluator_env_num = 5 num_simulations = 50 -update_per_collect = 50 +update_per_collect = 100 batch_size = 256 max_env_step = int(5e5) prob_random_action_in_bot = 0.5 diff --git a/zoo/board_games/gomoku/config/gomoku_alphazero_eval_config.py b/zoo/board_games/gomoku/config/gomoku_alphazero_eval_config.py index 9cbd67392..40e825cc8 100644 --- a/zoo/board_games/gomoku/config/gomoku_alphazero_eval_config.py +++ b/zoo/board_games/gomoku/config/gomoku_alphazero_eval_config.py @@ -1,4 +1,6 @@ -from zoo.board_games.gomoku.config.gomoku_alphazero_bot_mode_config import main_config, create_config +# from zoo.board_games.gomoku.config.gomoku_alphazero_bot_mode_config import main_config, create_config +from zoo.board_games.gomoku.config.gomoku_alphazero_league_config import main_config, create_config + from lzero.entry import eval_alphazero import numpy as np @@ -8,11 +10,15 @@ point to the ckpt file of the pretrained model, and an absolute path is recommended. In LightZero, the path is usually something like ``exp_name/ckpt/ckpt_best.pth.tar``. """ - model_path = './ckpt/ckpt_best.pth.tar' - seeds = [0] + # model_path = './ckpt/ckpt_best.pth.tar' + model_path = '/Users/puyuan/code/LightZero/league_tb_gomoku/ckpt_best_sp1.pth.tar' + + seeds = [0,1,2] num_episodes_each_seed = 5 # If True, you can play with the agent. main_config.env.agent_vs_human = False + # main_config.env.agent_vs_human = True + create_config.env_manager.type = 'base' main_config.env.evaluator_env_num = 1 main_config.env.n_evaluator_episode = 1 diff --git a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py index 37676b35f..6a1774bb6 100644 --- a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py +++ b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py @@ -10,12 +10,12 @@ n_episode = 32 evaluator_env_num = 5 num_simulations = 50 -update_per_collect = 50 +update_per_collect = 100 batch_size = 256 max_env_step = int(1e6) -sp_prob = 0. # TODO(pu): 0, 0.5, 1 +sp_prob = 0.5 # TODO(pu): 0, 0.5, 1 snapshot_the_player_in_iter_zero = True -one_phase_step = int(2e4) +one_phase_step = int(6e3) # collector_env_num = 2 # n_episode = 2 @@ -59,11 +59,12 @@ num_res_blocks=1, num_channels=32, ), + env_type='board_games', cuda=True, board_size=board_size, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, grad_clip_value=0.5, diff --git a/zoo/board_games/gomoku/config/gomoku_alphazero_sp_mode_config.py b/zoo/board_games/gomoku/config/gomoku_alphazero_sp_mode_config.py index 227af4275..16196e2fd 100644 --- a/zoo/board_games/gomoku/config/gomoku_alphazero_sp_mode_config.py +++ b/zoo/board_games/gomoku/config/gomoku_alphazero_sp_mode_config.py @@ -8,7 +8,7 @@ n_episode = 32 evaluator_env_num = 5 num_simulations = 50 -update_per_collect = 50 +update_per_collect = 100 batch_size = 256 max_env_step = int(5e5) prob_random_action_in_bot = 0.5 diff --git a/zoo/board_games/gomoku/config/gomoku_muzero_bot_mode_config.py b/zoo/board_games/gomoku/config/gomoku_muzero_bot_mode_config.py index ef0c87000..7b207357e 100644 --- a/zoo/board_games/gomoku/config/gomoku_muzero_bot_mode_config.py +++ b/zoo/board_games/gomoku/config/gomoku_muzero_bot_mode_config.py @@ -7,7 +7,7 @@ n_episode = 32 evaluator_env_num = 5 num_simulations = 50 -update_per_collect = 50 +update_per_collect = 100 reanalyze_ratio = 0. batch_size = 256 max_env_step = int(1e6) diff --git a/zoo/board_games/gomoku/config/gomoku_muzero_sp_mode_config.py b/zoo/board_games/gomoku/config/gomoku_muzero_sp_mode_config.py index 97e8cd9b2..038e60957 100644 --- a/zoo/board_games/gomoku/config/gomoku_muzero_sp_mode_config.py +++ b/zoo/board_games/gomoku/config/gomoku_muzero_sp_mode_config.py @@ -7,7 +7,7 @@ n_episode = 32 evaluator_env_num = 5 num_simulations = 50 -update_per_collect = 50 +update_per_collect = 100 batch_size = 256 max_env_step = int(1e6) reanalyze_ratio = 0. diff --git a/zoo/board_games/gomoku/envs/gomoku_env.py b/zoo/board_games/gomoku/envs/gomoku_env.py index bcb1a818e..0ad89b7e7 100644 --- a/zoo/board_games/gomoku/envs/gomoku_env.py +++ b/zoo/board_games/gomoku/envs/gomoku_env.py @@ -210,6 +210,7 @@ def step(self, action): # player 2's turn if self.agent_vs_human: bot_action = self.human_to_action() + # print(self.board) else: bot_action = self.bot_action() # bot_action = self.random_action() @@ -667,7 +668,7 @@ def human_to_action(self): Returns: An integer from the action space. """ - # print(self.board) + print(self.board) while True: try: row = int( diff --git a/zoo/board_games/tictactoe/config/tictactoe_alphazero_eval_config.py b/zoo/board_games/tictactoe/config/tictactoe_alphazero_eval_config.py index cd9409f17..d1a9616d8 100644 --- a/zoo/board_games/tictactoe/config/tictactoe_alphazero_eval_config.py +++ b/zoo/board_games/tictactoe/config/tictactoe_alphazero_eval_config.py @@ -10,7 +10,7 @@ point to the ckpt file of the pretrained model, and an absolute path is recommended. In LightZero, the path is usually something like ``exp_name/ckpt/ckpt_best.pth.tar``. """ - model_path = '/Users/puyuan/code/LightZero/sp_tb/ckpt_best_sp0.pth.tar' + model_path = '/Users/puyuan/code/LightZero/league_tb_tictactoe/ckpt_best_sp0.pth.tar' seeds = [0] num_episodes_each_seed = 5 From 5dfa97cc6f7989438ddc577f088b9265518aa25d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Wed, 31 May 2023 01:54:38 +0800 Subject: [PATCH 12/34] polish(pu): polish gomoku eval render --- .../config/gomoku_alphazero_eval_config.py | 10 ++++---- .../config/gomoku_alphazero_league_config.py | 4 +++- zoo/board_games/gomoku/envs/gomoku_env.py | 11 +++++---- .../gomoku/envs/test_gomoku_rule_bot_v0.py | 24 +++++++++++++------ zoo/board_games/gomoku/envs/utils.py | 6 +++-- 5 files changed, 37 insertions(+), 18 deletions(-) diff --git a/zoo/board_games/gomoku/config/gomoku_alphazero_eval_config.py b/zoo/board_games/gomoku/config/gomoku_alphazero_eval_config.py index 40e825cc8..587d16e8f 100644 --- a/zoo/board_games/gomoku/config/gomoku_alphazero_eval_config.py +++ b/zoo/board_games/gomoku/config/gomoku_alphazero_eval_config.py @@ -11,13 +11,15 @@ In LightZero, the path is usually something like ``exp_name/ckpt/ckpt_best.pth.tar``. """ # model_path = './ckpt/ckpt_best.pth.tar' - model_path = '/Users/puyuan/code/LightZero/league_tb_gomoku/ckpt_best_sp1.pth.tar' + # model_path = '/Users/puyuan/code/LightZero/league_tb_gomoku/ckpt_best_sp1.pth.tar' + model_path = '/Users/puyuan/code/LightZero/league_tb_gomoku_0531/ckpt_best_adamw.pth.tar' seeds = [0,1,2] - num_episodes_each_seed = 5 + # seeds = [0] + num_episodes_each_seed = 10 # If True, you can play with the agent. - main_config.env.agent_vs_human = False - # main_config.env.agent_vs_human = True + # main_config.env.agent_vs_human = False + main_config.env.agent_vs_human = True create_config.env_manager.type = 'base' main_config.env.evaluator_env_num = 1 diff --git a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py index 6a1774bb6..59ae48a1d 100644 --- a/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py +++ b/zoo/board_games/gomoku/config/gomoku_alphazero_league_config.py @@ -4,7 +4,9 @@ # begin of the most frequently changed config specified by the user # ============================================================== board_size = 6 # default_size is 15 -prob_random_action_in_bot = 0.5 +# prob_random_action_in_bot = 0.5 +prob_random_action_in_bot = 0 + collector_env_num = 32 n_episode = 32 diff --git a/zoo/board_games/gomoku/envs/gomoku_env.py b/zoo/board_games/gomoku/envs/gomoku_env.py index 0ad89b7e7..615c15705 100644 --- a/zoo/board_games/gomoku/envs/gomoku_env.py +++ b/zoo/board_games/gomoku/envs/gomoku_env.py @@ -200,9 +200,10 @@ def step(self, action): # player 1's turn timestep_player1 = self._player_step(action) + if self.agent_vs_human: + # print(self.board) + self.render() # Note: visualize if timestep_player1.done: - if self.agent_vs_human: - print(self.board) # in eval_mode, we set to_play as None/-1, because we don't consider the alternation between players timestep_player1.obs['to_play'] = -1 return timestep_player1 @@ -216,6 +217,8 @@ def step(self, action): # bot_action = self.random_action() timestep_player2 = self._player_step(bot_action) + if self.agent_vs_human: + self.render() # Note: visualize # the eval_episode_return is calculated from Player 1's perspective timestep_player2.info['eval_episode_return'] = -timestep_player2.reward @@ -482,8 +485,8 @@ def rule_bot_v0(self): if abs(sum(diag)) >= min_to_connect: # if diagonal has three same pieces and two empty position, or four same pieces and one opponent piece. # e.g., case1: .xxx. , case2: oxxxx - # find the index in the diag vector + # find the index in the diag vector zero_position_index = np.where(diag == 0)[0] if zero_position_index.shape[0] == 0: logging.debug('there is no empty position in this searched five positions, continue to search...') @@ -668,7 +671,7 @@ def human_to_action(self): Returns: An integer from the action space. """ - print(self.board) + # print(self.board) while True: try: row = int( diff --git a/zoo/board_games/gomoku/envs/test_gomoku_rule_bot_v0.py b/zoo/board_games/gomoku/envs/test_gomoku_rule_bot_v0.py index 2dec03ca0..851199696 100644 --- a/zoo/board_games/gomoku/envs/test_gomoku_rule_bot_v0.py +++ b/zoo/board_games/gomoku/envs/test_gomoku_rule_bot_v0.py @@ -11,8 +11,10 @@ scale=True, agent_vs_human=False, bot_action_type='v0', # {'v0', 'v1', 'alpha_beta_pruning'} - prob_random_action_in_bot=0.5, + # prob_random_action_in_bot=0.5, + prob_random_action_in_bot=0., check_action_to_connect4_in_bot_v0=False, + # check_action_to_connect4_in_bot_v0=True, ) @@ -27,9 +29,9 @@ def test_naive(self): # print('init board state: ', obs) env.render() while True: - action = env.bot_action() + # action = env.bot_action() # action = env.random_action() - # action = env.human_to_action() + action = env.human_to_action() print('action index of player 1 is:', action) print('player 1: ' + env.action_to_string(action)) obs, reward, done, info = env.step(action) @@ -61,10 +63,18 @@ def test_naive(self): def test_v0_vs_v1(self): """ + check_action_to_connect4_in_bot_v0=True board_size=6, test_100_episodes: ================================================= - v0 vs v1: 0 bot_v0 win, 16 bot_v1 win, 84 draw + v0 vs v1: 0 bot_v0 win, 9 bot_v1 win, 91 draw v1 vs v0: 1 bot_v0 win, 35 bot_v1 win, 64 draw + ================================================= + + check_action_to_connect4_in_bot_v0=False + board_size=6, test_100_episodes: + ================================================= + v0 vs v1: 1 bot_v0 win, 9 bot_v1 win, 90 draw + v1 vs v0: 3 bot_v0 win, 25 bot_v1 win, 72 draw v0 vs v0: 100 draw v1 vs v1: 100 draw v0 vs random: 93 bot_v0 win, 35 random win, 7 draw @@ -82,7 +92,7 @@ def test_v0_vs_v1(self): ================================================= """ env = GomokuEnv(cfg) - test_episodes = 10 + test_episodes = 100 for i in range(test_episodes): obs = env.reset() # print('init board state: ', obs) @@ -124,5 +134,5 @@ def test_v0_vs_v1(self): test = TestExpertActionV0() -# test.test_v0_vs_v1() -test.test_naive() +test.test_v0_vs_v1() +# test.test_naive() diff --git a/zoo/board_games/gomoku/envs/utils.py b/zoo/board_games/gomoku/envs/utils.py index 2bbaa01f1..5671ea5b7 100644 --- a/zoo/board_games/gomoku/envs/utils.py +++ b/zoo/board_games/gomoku/envs/utils.py @@ -1,4 +1,5 @@ import copy +import sys import numpy as np @@ -15,10 +16,10 @@ def check_action_to_special_connect4_case2(board): board = copy.deepcopy(board) if (board == [1, 1, 1, 0, 0]).all() or (board == [-1, -1, -1, 0, 0]).all() or ( np.flip(board) == [1, 1, 1, 0, 0]).all() or ( - np.flip(board) == [-1, -1, -1, 0, 0]).all() \ + np.flip(board) == [-1, -1, -1, 0, 0]).all() or \ (board == [1, 1, 0, 1, 0]).all() or (board == [-1, -1, 0, -1, 0]).all() or ( np.flip(board) == [1, 1, 0, 1, 0]).all() or ( - np.flip(board) == [-1, -1, 0, -1, 0]).all() \ + np.flip(board) == [-1, -1, 0, -1, 0]).all() or \ (board == [1, 0, 1, 1, 0]).all() or (board == [-1, 0, -1, -1, 0]).all() or ( np.flip(board) == [1, 0, 1, 1, 0]).all() or ( np.flip(board) == [-1, 0, -1, -1, 0]).all(): @@ -27,6 +28,7 @@ def check_action_to_special_connect4_case2(board): return False + def check_action_to_connect4(board): board = copy.deepcopy(board) if ((board == -1).sum() == 3 and (board == 0).sum() == 2) or \ From 73c18fd6c8a5b0f6dc32f7e31c4c0c261c47b871 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Thu, 22 Jun 2023 23:38:17 +0800 Subject: [PATCH 13/34] feature(pu): add init version of go env and related alphazero sp config --- lzero/mcts/ptree/ptree_az.py | 3 +- .../tests/atari_efficientzero_config_test.py | 2 +- .../tictactoe_muzero_bot_mode_config_test.py | 2 +- lzero/policy/alphazero.py | 4 +- lzero/policy/sampled_efficientzero.py | 2 +- .../go/config/go_alphazero_bot_mode_config.py | 96 +++ .../go/config/go_alphazero_eval_config.py | 43 ++ .../go/config/go_alphazero_sp-mode_config.py | 1 - .../go/config/go_alphazero_sp_mode_config.py | 108 ++++ zoo/board_games/go/envs/go_env.py | 581 +++++++++++++----- zoo/board_games/go/envs/go_env_bkp.py | 330 ++++++++++ zoo/board_games/go/envs/test_go_env.py | 54 +- .../gomoku_alphazero_bot_mode_config.py | 2 +- .../config/gomoku_alphazero_sp_mode_config.py | 2 +- .../gomoku_gumbel_muzero_bot_mode_config.py | 2 +- .../config/gomoku_muzero_bot_mode_config.py | 2 +- .../config/gomoku_muzero_sp_mode_config.py | 2 +- .../tictactoe_alphazero_bot_mode_config.py | 2 +- .../tictactoe_alphazero_sp_mode_config.py | 2 +- ...tictactoe_gumbel_muzero_bot_mode_config.py | 2 +- .../tictactoe_muzero_bot_mode_config.py | 2 +- .../config/tictactoe_muzero_sp_mode_config.py | 2 +- .../tictactoe/envs/tictactoe_env.py | 10 + ...alwalker_cont_disc_efficientzero_config.py | 2 +- ..._cont_disc_sampled_efficientzero_config.py | 2 +- ...alker_cont_sampled_efficientzero_config.py | 2 +- ...arlander_cont_disc_efficientzero_config.py | 2 +- ..._cont_disc_sampled_efficientzero_config.py | 2 +- ...ander_cont_sampled_efficientzero_config.py | 2 +- .../lunarlander_disc_efficientzero_config.py | 2 +- .../lunarlander_disc_gumbel_muzero_config.py | 2 +- .../config/lunarlander_disc_muzero_config.py | 2 +- .../config/cartpole_efficientzero_config.py | 2 +- .../config/cartpole_gumbel_muzero_config.py | 2 +- .../cartpole/config/cartpole_muzero_config.py | 2 +- .../cartpole_sampled_efficientzero_config.py | 2 +- ...pendulum_cont_disc_efficientzero_config.py | 2 +- .../pendulum_cont_disc_muzero_config.py | 2 +- ..._cont_disc_sampled_efficientzero_config.py | 2 +- ...dulum_cont_sampled_efficientzero_config.py | 2 +- 40 files changed, 1102 insertions(+), 188 deletions(-) create mode 100644 zoo/board_games/go/config/go_alphazero_bot_mode_config.py create mode 100644 zoo/board_games/go/config/go_alphazero_eval_config.py delete mode 100644 zoo/board_games/go/config/go_alphazero_sp-mode_config.py create mode 100644 zoo/board_games/go/config/go_alphazero_sp_mode_config.py create mode 100644 zoo/board_games/go/envs/go_env_bkp.py diff --git a/lzero/mcts/ptree/ptree_az.py b/lzero/mcts/ptree/ptree_az.py index 44d91573d..aeca56ad4 100644 --- a/lzero/mcts/ptree/ptree_az.py +++ b/lzero/mcts/ptree/ptree_az.py @@ -246,8 +246,8 @@ def _select_child(self, node: Node, simulate_env: Type[BaseEnv]) -> Tuple[Union[ action = None child = None best_score = -9999999 + # print(simulate_env._raw_env._go.board, simulate_env.legal_actions) for action_tmp, child_tmp in node.children.items(): - # print(a, simulate_env.legal_actions) if action_tmp in simulate_env.legal_actions: score = self._ucb_score(node, child_tmp) if score > best_score: @@ -271,6 +271,7 @@ def _expand_leaf_node(self, node: Node, simulate_env: Type[BaseEnv], policy_forw - leaf_value (:obj:`Bool`): the leaf node's value. """ action_probs_dict, leaf_value = policy_forward_fn(simulate_env) + # simulate_env._raw_env._go.board for action, prior_p in action_probs_dict.items(): if action in simulate_env.legal_actions: node.children[action] = Node(parent=node, prior_p=prior_p) diff --git a/lzero/mcts/tests/atari_efficientzero_config_test.py b/lzero/mcts/tests/atari_efficientzero_config_test.py index 91101d7da..64f863dbc 100644 --- a/lzero/mcts/tests/atari_efficientzero_config_test.py +++ b/lzero/mcts/tests/atari_efficientzero_config_test.py @@ -72,7 +72,7 @@ update_per_collect=update_per_collect, batch_size=batch_size, lr_piecewise_constant_decay=True, - optim_type='Adam', + optim_type='AdamW', learning_rate=0.2, # init lr for manually decay schedule n_episode=n_episode, eval_freq=int(2e3), diff --git a/lzero/mcts/tests/tictactoe_muzero_bot_mode_config_test.py b/lzero/mcts/tests/tictactoe_muzero_bot_mode_config_test.py index f5e7463cf..0874ccc06 100644 --- a/lzero/mcts/tests/tictactoe_muzero_bot_mode_config_test.py +++ b/lzero/mcts/tests/tictactoe_muzero_bot_mode_config_test.py @@ -54,7 +54,7 @@ env_type='board_games', update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, # lr for Adam optimizer grad_clip_value=0.5, diff --git a/lzero/policy/alphazero.py b/lzero/policy/alphazero.py index 1a7717a7b..2d6b13a7e 100644 --- a/lzero/policy/alphazero.py +++ b/lzero/policy/alphazero.py @@ -241,12 +241,14 @@ def _forward_collect(self, envs: Dict, obs: Dict, temperature: float = 1) -> Dic envs[env_id], policy_forward_fn=self._policy_value_fn, temperature=self.collect_mcts_temperature, - sample=True + # sample=False, + sample=True, ) output[env_id] = { 'action': action, 'probs': mcts_probs, } + return output def _init_eval(self) -> None: diff --git a/lzero/policy/sampled_efficientzero.py b/lzero/policy/sampled_efficientzero.py index 83ac3aa38..e431fb830 100644 --- a/lzero/policy/sampled_efficientzero.py +++ b/lzero/policy/sampled_efficientzero.py @@ -111,7 +111,7 @@ class SampledEfficientZeroPolicy(Policy): # (str) Optimizer for training policy network. ['SGD', 'Adam', 'AdamW'] optim_type='SGD', learning_rate=0.2, # init lr for manually decay schedule - # optim_type='Adam', + # optim_type='AdamW', # lr_piecewise_constant_decay=False, # learning_rate=0.003, # lr for Adam optimizer # (float) Weight uniform initialization range in the last output layer diff --git a/zoo/board_games/go/config/go_alphazero_bot_mode_config.py b/zoo/board_games/go/config/go_alphazero_bot_mode_config.py new file mode 100644 index 000000000..1cac41cc2 --- /dev/null +++ b/zoo/board_games/go/config/go_alphazero_bot_mode_config.py @@ -0,0 +1,96 @@ +from easydict import EasyDict + +# ============================================================== +# begin of the most frequently changed config specified by the user +# ============================================================== +board_size = 6 # default_size is 15 +collector_env_num = 32 +n_episode = 32 +evaluator_env_num = 5 +num_simulations = 50 +update_per_collect = 50 +batch_size = 256 +max_env_step = int(5e5) +prob_random_action_in_bot = 0.5 +# ============================================================== +# end of the most frequently changed config specified by the user +# ============================================================== +gomoku_alphazero_config = dict( + exp_name= + f'data_az_ptree/gomoku_alphazero_bot-mode_rand{prob_random_action_in_bot}_ns{num_simulations}_upc{update_per_collect}_seed0', + env=dict( + board_size=board_size, + battle_mode='play_with_bot_mode', + bot_action_type='v0', + prob_random_action_in_bot=prob_random_action_in_bot, + channel_last=False, # NOTE + collector_env_num=collector_env_num, + evaluator_env_num=evaluator_env_num, + n_evaluator_episode=evaluator_env_num, + manager=dict(shared_memory=False, ), + ), + policy=dict( + torch_compile=False, + tensor_float_32=False, + model=dict( + observation_shape=(3, board_size, board_size), + action_space_size=int(1 * board_size * board_size), + num_res_blocks=1, + num_channels=32, + ), + cuda=True, + board_size=board_size, + update_per_collect=update_per_collect, + batch_size=batch_size, + optim_type='AdamW', + lr_piecewise_constant_decay=False, + learning_rate=0.003, + grad_clip_value=0.5, + value_weight=1.0, + entropy_weight=0.0, + n_episode=n_episode, + eval_freq=int(2e3), + mcts=dict(num_simulations=num_simulations), + collector_env_num=collector_env_num, + evaluator_env_num=evaluator_env_num, + ), +) + +gomoku_alphazero_config = EasyDict(gomoku_alphazero_config) +main_config = gomoku_alphazero_config + +gomoku_alphazero_create_config = dict( + env=dict( + type='gomoku', + import_names=['zoo.board_games.gomoku.envs.gomoku_env'], + ), + env_manager=dict(type='subprocess'), + policy=dict( + type='alphazero', + import_names=['lzero.policy.alphazero'], + ), + collector=dict( + type='episode_alphazero', + get_train_sample=False, + import_names=['lzero.worker.alphazero_collector'], + ), + evaluator=dict( + type='alphazero', + import_names=['lzero.worker.alphazero_evaluator'], + ) +) +gomoku_alphazero_create_config = EasyDict(gomoku_alphazero_create_config) +create_config = gomoku_alphazero_create_config + +if __name__ == '__main__': + if main_config.policy.tensor_float_32: + import torch + + # The flag below controls whether to allow TF32 on matmul. This flag defaults to False + # in PyTorch 1.12 and later. + torch.backends.cuda.matmul.allow_tf32 = True + # The flag below controls whether to allow TF32 on cuDNN. This flag defaults to True. + torch.backends.cudnn.allow_tf32 = True + + from lzero.entry import train_alphazero + train_alphazero([main_config, create_config], seed=0, max_env_step=max_env_step) diff --git a/zoo/board_games/go/config/go_alphazero_eval_config.py b/zoo/board_games/go/config/go_alphazero_eval_config.py new file mode 100644 index 000000000..9cbd67392 --- /dev/null +++ b/zoo/board_games/go/config/go_alphazero_eval_config.py @@ -0,0 +1,43 @@ +from zoo.board_games.gomoku.config.gomoku_alphazero_bot_mode_config import main_config, create_config +from lzero.entry import eval_alphazero +import numpy as np + +if __name__ == '__main__': + """ + model_path (:obj:`Optional[str]`): The pretrained model path, which should + point to the ckpt file of the pretrained model, and an absolute path is recommended. + In LightZero, the path is usually something like ``exp_name/ckpt/ckpt_best.pth.tar``. + """ + model_path = './ckpt/ckpt_best.pth.tar' + seeds = [0] + num_episodes_each_seed = 5 + # If True, you can play with the agent. + main_config.env.agent_vs_human = False + create_config.env_manager.type = 'base' + main_config.env.evaluator_env_num = 1 + main_config.env.n_evaluator_episode = 1 + total_test_episodes = num_episodes_each_seed * len(seeds) + returns_mean_seeds = [] + returns_seeds = [] + for seed in seeds: + returns_mean, returns = eval_alphazero( + [main_config, create_config], + seed=seed, + num_episodes_each_seed=num_episodes_each_seed, + print_seed_details=True, + model_path=model_path + ) + returns_mean_seeds.append(returns_mean) + returns_seeds.append(returns) + + returns_mean_seeds = np.array(returns_mean_seeds) + returns_seeds = np.array(returns_seeds) + + print("=" * 20) + print(f'We eval total {len(seeds)} seeds. In each seed, we eval {num_episodes_each_seed} episodes.') + print(f'In seeds {seeds}, returns_mean_seeds is {returns_mean_seeds}, returns is {returns_seeds}') + print('In all seeds, reward_mean:', returns_mean_seeds.mean(), end='. ') + print( + f'win rate: {len(np.where(returns_seeds == 1.)[0]) / total_test_episodes}, draw rate: {len(np.where(returns_seeds == 0.)[0]) / total_test_episodes}, lose rate: {len(np.where(returns_seeds == -1.)[0]) / total_test_episodes}' + ) + print("=" * 20) diff --git a/zoo/board_games/go/config/go_alphazero_sp-mode_config.py b/zoo/board_games/go/config/go_alphazero_sp-mode_config.py deleted file mode 100644 index 02b37e1f1..000000000 --- a/zoo/board_games/go/config/go_alphazero_sp-mode_config.py +++ /dev/null @@ -1 +0,0 @@ -# TODO diff --git a/zoo/board_games/go/config/go_alphazero_sp_mode_config.py b/zoo/board_games/go/config/go_alphazero_sp_mode_config.py new file mode 100644 index 000000000..39fe2bca0 --- /dev/null +++ b/zoo/board_games/go/config/go_alphazero_sp_mode_config.py @@ -0,0 +1,108 @@ +from easydict import EasyDict + +# ============================================================== +# begin of the most frequently changed config specified by the user +# ============================================================== +board_size = 6 # default_size is 15 +collector_env_num = 32 +n_episode = 32 +evaluator_env_num = 5 +num_simulations = 50 +update_per_collect = 50 +batch_size = 256 +max_env_step = int(5e5) +prob_random_action_in_bot = 0. + +# board_size = 6 # default_size is 15 +# collector_env_num = 1 +# n_episode = 1 +# evaluator_env_num = 1 +# num_simulations = 2 +# update_per_collect = 2 +# batch_size = 2 +# max_env_step = int(5e5) +# prob_random_action_in_bot = 0. +# ============================================================== +# end of the most frequently changed config specified by the user +# ============================================================== +go_alphazero_config = dict( + exp_name= + f'data_az_ptree/go_alphazero_sp-mode_rand{prob_random_action_in_bot}_ns{num_simulations}_upc{update_per_collect}_seed0', + env=dict( + board_size=board_size, + komi=7.5, + battle_mode='self_play_mode', + bot_action_type='v0', + prob_random_action_in_bot=prob_random_action_in_bot, + channel_last=True, + collector_env_num=collector_env_num, + evaluator_env_num=evaluator_env_num, + n_evaluator_episode=evaluator_env_num, + manager=dict(shared_memory=False, ), + ), + policy=dict( + torch_compile=False, + tensor_float_32=False, + model=dict( + observation_shape=(board_size, board_size, 17), + action_space_size=int(1 * board_size * board_size + 1), + num_res_blocks=1, + num_channels=32, + ), + cuda=True, + board_size=board_size, + update_per_collect=update_per_collect, + batch_size=batch_size, + optim_type='AdamW', + lr_piecewise_constant_decay=False, + learning_rate=0.003, + manual_temperature_decay=True, + grad_clip_value=0.5, + value_weight=1.0, + entropy_weight=0.0, + n_episode=n_episode, + eval_freq=int(2e3), + mcts=dict(num_simulations=num_simulations), + collector_env_num=collector_env_num, + evaluator_env_num=evaluator_env_num, + ), +) + +go_alphazero_config = EasyDict(go_alphazero_config) +main_config = go_alphazero_config + +go_alphazero_create_config = dict( + env=dict( + type='go', + import_names=['zoo.board_games.go.envs.go_env'], + ), + env_manager=dict(type='subprocess'), + policy=dict( + type='alphazero', + import_names=['lzero.policy.alphazero'], + ), + collector=dict( + type='episode_alphazero', + get_train_sample=False, + import_names=['lzero.worker.alphazero_collector'], + ), + evaluator=dict( + type='alphazero', + import_names=['lzero.worker.alphazero_evaluator'], + ) +) +go_alphazero_create_config = EasyDict(go_alphazero_create_config) +create_config = go_alphazero_create_config + +if __name__ == '__main__': + if main_config.policy.tensor_float_32: + import torch + + # The flag below controls whether to allow TF32 on matmul. This flag defaults to False + # in PyTorch 1.12 and later. + torch.backends.cuda.matmul.allow_tf32 = True + # The flag below controls whether to allow TF32 on cuDNN. This flag defaults to True. + torch.backends.cudnn.allow_tf32 = True + + from lzero.entry import train_alphazero + train_alphazero([main_config, create_config], seed=0, max_env_step=max_env_step) diff --git a/zoo/board_games/go/envs/go_env.py b/zoo/board_games/go/envs/go_env.py index dd3803468..34f0a521c 100644 --- a/zoo/board_games/go/envs/go_env.py +++ b/zoo/board_games/go/envs/go_env.py @@ -1,16 +1,19 @@ -""" -Adapt the Go environment in PettingZoo (https://github.com/Farama-Foundation/PettingZoo) to the BaseEnv interface. -""" +import copy +from ditk import logging import os import sys +from typing import List +import gym import numpy as np import pygame from ding.envs import BaseEnv, BaseEnvTimestep from ding.utils import ENV_REGISTRY +from easydict import EasyDict from gym import spaces -from pettingzoo.classic.go import coords, go +from pettingzoo.classic import go_v5 +from pettingzoo.classic.go import coords, go_base from pettingzoo.utils.agent_selector import agent_selector @@ -25,192 +28,406 @@ def get_image(path): return sfc -@ENV_REGISTRY.register('Go') +@ENV_REGISTRY.register('go') class GoEnv(BaseEnv): + """ + Overview: + Go environment. + board: X black, O white, . empty + Represent a board as a numpy array, with 0 empty, 1 is black, -1 is white. + + self._raw_env._go.to_play: 1 black, -1 white + Interface: + reset, step, seed, close, render, close, seed + Property: + action_space, observation_space, reward_range, spec + + """ + + config = dict( + env_name="Go", + battle_mode='self_play_mode', + mcts_mode='self_play_mode', # only used in AlphaZero + bot_action_type='v0', # {'v0', 'alpha_beta_pruning'} + agent_vs_human=False, + prob_random_agent=0, + prob_expert_agent=0, + channel_last=True, + scale=True, + stop_value=1, + ) + + @classmethod + def default_config(cls: type) -> EasyDict: + cfg = EasyDict(copy.deepcopy(cls.config)) + cfg.cfg_type = cls.__name__ + 'Dict' + return cfg + + @property + def current_player(self): + return self._current_player + + @property + def current_player_index(self): + """ + current_player_index = 0, current_player = 1 + current_player_index = 1, current_player = 2 + """ + return 0 if self._current_player == 1 else 1 + + @property + def to_play(self): + return self.players[0] if self.current_player == self.players[1] else self.players[1] + + @property + def current_player_to_compute_bot_action(self): + """ + Overview: to compute expert action easily. + """ + return -1 if self.current_player == 1 else 1 + + # def __init__(self, board_size: int = 19, komi: float = 7.5): + def __init__(self, cfg=None): - def __init__(self, board_size: int = 19, komi: float = 7.5): # board_size: a int, representing the board size (board has a board_size x board_size shape) # komi: a float, representing points given to the second player. - self._overwrite_go_global_variables(board_size=board_size) - self._komi = komi - + self.cfg = cfg + self.channel_last = cfg.channel_last + self.scale = cfg.scale + self.battle_mode = cfg.battle_mode + # The mode of interaction between the agent and the environment. + assert self.battle_mode in ['self_play_mode', 'play_with_bot_mode', 'eval_mode'] + # The mode of MCTS is only used in AlphaZero. + self.mcts_mode = 'self_play_mode' + + self.board_size = cfg.board_size + self.prob_random_agent = cfg.prob_random_agent + self.prob_random_action_in_bot = cfg.prob_random_action_in_bot + self.channel_last = cfg.channel_last + self.scale = cfg.scale + self.agent_vs_human = cfg.agent_vs_human + self.bot_action_type = cfg.bot_action_type + + self.players = [1, 2] + self.board_markers = [str(i + 1) for i in range(self.board_size)] + self.total_num_actions = self.board_size * self.board_size + 1 + + self._komi = cfg.komi + self.board_size = cfg.board_size self.agents = ['black_0', 'white_0'] self.num_agents = len(self.agents) - self.possible_agents = self.agents[:] + self._agent_selector = agent_selector(self.agents) self.has_reset = False - self.screen = None - self._observation_space = self._convert_to_dict( - [ - spaces.Dict( - { - 'observation': spaces.Box(low=0, high=1, shape=(self._N, self._N, 17), dtype=bool), - 'action_mask': spaces.Box(low=0, high=1, shape=((self._N * self._N) + 1, ), dtype=np.int8) - } - ) for _ in range(self.num_agents) - ] - ) + self._observation_space = spaces.Dict( + { + 'observation': spaces.Box(low=0, high=1, shape=(self.board_size, self.board_size, 17), + dtype=bool), + 'action_mask': spaces.Box(low=0, high=1, shape=((self.board_size * self.board_size) + 1,), + dtype=np.int8) + }) + self._action_space = spaces.Discrete(self.board_size * self.board_size + 1) + self._reward_space = gym.spaces.Box(low=0, high=1, shape=(1,), dtype=np.float32) - self._action_space = self._convert_to_dict( - [spaces.Discrete(self._N * self._N + 1) for _ in range(self.num_agents)] - ) + self.board_history = np.zeros((self.board_size, self.board_size, 16), dtype=bool) - self._agent_selector = agent_selector(self.agents) - self.board_history = np.zeros((self._N, self._N, 16), dtype=bool) - - def _overwrite_go_global_variables(self, board_size: int): - self._N = board_size - go.N = self._N - go.ALL_COORDS = [(i, j) for i in range(self._N) for j in range(self._N)] - go.EMPTY_BOARD = np.zeros([self._N, self._N], dtype=np.int8) - go.NEIGHBORS = { - (x, y): list(filter(self._check_bounds, [(x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)])) - for x, y in go.ALL_COORDS - } - go.DIAGONALS = { - (x, y): list(filter(self._check_bounds, [(x + 1, y + 1), (x + 1, y - 1), (x - 1, y + 1), (x - 1, y - 1)])) - for x, y in go.ALL_COORDS - } - return + # Represent a board as a numpy array, with 0 empty, 1 is black, -1 is white. + def reset(self, start_player_index=0, init_state=None): + self.start_player_index = start_player_index + self._current_player = self.players[self.start_player_index] - def _check_bounds(self, c): - return 0 <= c[0] < self._N and 0 <= c[1] < self._N + if self.current_player == 1: + agent_id = 'black_0' + self._agent_selector = agent_selector(['black_0', 'white_0']) + elif self.current_player == 2: + agent_id = 'white_0' + self._agent_selector = agent_selector(['white_0', 'black_0']) - def _encode_player_plane(self, agent): - if agent == self.possible_agents[0]: - return np.zeros([self._N, self._N], dtype=bool) + self.agent_selection = self._agent_selector.next() + + self.has_reset = True + self._go = go_v5.env(board_size=self.board_size, komi=self._komi) + # self._go = raw_env(board_size=self.board_size, komi=self._komi) + self._go.reset() + self._raw_env = self._go.env.env.env + + if init_state is not None: + # Represent a board as a numpy array, with 0 empty, 1 is black, -1 is white. + self._raw_env._go = go_base.Position(board=copy.deepcopy(init_state), komi=self._komi, + to_play=1 if self.start_player_index == 0 else -1) else: - return np.ones([self._N, self._N], dtype=bool) - - def _encode_board_planes(self, agent): - agent_factor = go.BLACK if agent == self.possible_agents[0] else go.WHITE - current_agent_plane_idx = np.where(self._go.board == agent_factor) - opponent_agent_plane_idx = np.where(self._go.board == -agent_factor) - current_agent_plane = np.zeros([self._N, self._N], dtype=bool) - opponent_agent_plane = np.zeros([self._N, self._N], dtype=bool) - current_agent_plane[current_agent_plane_idx] = 1 - opponent_agent_plane[opponent_agent_plane_idx] = 1 - return current_agent_plane, opponent_agent_plane + self._raw_env._go = go_base.Position(board=np.zeros((self.board_size, self.board_size), dtype="int32"), + komi=self._komi, to_play=1 if self.start_player_index == 0 else -1) - def _int_to_name(self, ind): - return self.possible_agents[ind] + self._cumulative_rewards = self._convert_to_dict(np.array([0.0, 0.0])) + self.rewards = self._convert_to_dict(np.array([0.0, 0.0])) - def _name_to_int(self, name): - return self.possible_agents.index(name) + self.dones = self._convert_to_dict([False for _ in range(self.num_agents)]) + self.infos = self._convert_to_dict([{} for _ in range(self.num_agents)]) - def _convert_to_dict(self, list_of_list): - return dict(zip(self.possible_agents, list_of_list)) + self.next_legal_moves = self._raw_env._encode_legal_actions(self._raw_env._go.all_legal_moves()) + self.board_history = np.zeros((self.board_size, self.board_size, 16), dtype=bool) - def _encode_legal_actions(self, actions): - return np.where(actions == 1)[0] + for agent, reward in self.rewards.items(): + self._cumulative_rewards[agent] += reward - def _encode_rewards(self, result): - return [1, -1] if result == 1 else [-1, 1] + # obs = self._go.observe(agent_id) + # obs = self._raw_env.observe(agent_id) + obs = self.observe(agent_id) - @property - def current_player(self): - return self.current_player_index + # obs['action_mask'] is the action mask for the last player + self.action_mask = np.zeros(self.total_num_actions, 'int8') + self.action_mask[self.legal_actions] = 1 - @property - def to_play(self): - return self.current_player_index + obs['action_mask'] = self.action_mask + obs['observation'] = obs['observation'].astype(int) + obs['board'] = copy.deepcopy(self._raw_env._go.board) + obs['current_player_index'] = self.current_player_index + obs['to_play'] = self.current_player - def reset(self): - self.has_reset = True - self._go = go.Position(board=None, komi=self._komi) - self.agents = self.possible_agents[:] - self._agent_selector.reinit(self.agents) - self.agent_selection = self._agent_selector.reset() - self._cumulative_rewards = self._convert_to_dict(np.array([0.0, 0.0])) - self.rewards = self._convert_to_dict(np.array([0.0, 0.0])) - self.dones = self._convert_to_dict([False for _ in range(self.num_agents)]) - self.infos = self._convert_to_dict([{} for _ in range(self.num_agents)]) - self.next_legal_moves = self._encode_legal_actions(self._go.all_legal_moves()) - self._last_obs = self.observe(self.agents[0]) - self.board_history = np.zeros((self._N, self._N, 16), dtype=bool) + return obs - self.current_player_index = 0 + def _player_step(self, action): + if self.current_player == 1: + agent_id = 'black_0' + elif self.current_player == 2: + agent_id = 'white_0' + + if action in self.legal_actions: + self._raw_env._go = self._raw_env._go.play_move(coords.from_flat(action)) + else: + logging.warning( + f"You input illegal action: {action}, the legal_actions are {self.legal_actions}. " + f"Now we randomly choice a action from self.legal_actions." + ) + action = np.random.choice(self.legal_actions) + self._raw_env._go = self._raw_env._go.play_move(coords.from_flat(action)) + + # try: + # self._raw_env._go = self._raw_env._go.play_move(coords.from_flat(action)) + # except: + # print('action: ', action) + # print('board:', self._raw_env._go.board) + # import sys + # sys.exit(2) + + # obs = self._go.observe(agent_id) + # obs = self._raw_env.observe(agent_id) + obs = self.observe(agent_id) + + current_agent_plane, opponent_agent_plane = self._raw_env._encode_board_planes(agent_id) + self.board_history = np.dstack((current_agent_plane, opponent_agent_plane, self.board_history[:, :, :-2])) + # self.board_history[:,:,0], self.board_history[:,:,1] + + # next_player: 'black_0', 'white_0' + """ + NOTE: here exchange the player + """ + self.agent_selection = self._agent_selector.next() + self._current_player = self.to_play + + # obs['action_mask'] is the action mask for the last player + action_mask = np.zeros(self.total_num_actions, 'int8') + action_mask[self.legal_actions] = 1 + obs['action_mask'] = action_mask + obs['observation'] = obs['observation'].astype(int) + obs['board'] = copy.deepcopy(self._raw_env._go.board) + # obs['current_player_index'] = self.players.index(self.current_player) + obs['current_player_index'] = self.current_player_index + obs['to_play'] = self.current_player + + if self._raw_env._go.is_game_over(): + self._raw_env.terminations = self._convert_to_dict( + [True for _ in range(self.num_agents)] + ) + self.rewards = self._convert_to_dict( + self._encode_rewards(self._raw_env._go.result()) + ) + self.next_legal_moves = [self.board_size * self.board_size] + else: + self.next_legal_moves = self._encode_legal_actions(self._raw_env._go.all_legal_moves()) for agent, reward in self.rewards.items(): self._cumulative_rewards[agent] += reward agent = self.agent_selection - current_index = self.agents.index(agent) - self.current_player_index = current_index - obs = self.observe(agent) - return obs + # self.dones[agent] = ( + # self._raw_env.terminations[agent_id] + # or self._raw_env.truncations[agent_id] + # ) + self.dones[agent] = ( + self._raw_env.terminations[agent] + or self._raw_env.truncations[agent] + ) + if self.dones[agent]: + self.infos[agent]['eval_episode_return'] = self._cumulative_rewards[agent] + + return BaseEnvTimestep(obs, self._cumulative_rewards[agent], self.dones[agent], self.infos[agent]) + + def step(self, action): + if self.battle_mode == 'self_play_mode': + if np.random.rand() < self.prob_random_agent: + action = self.random_action() + timestep = self._player_step(action) + if timestep.done: + # The eval_episode_return is calculated from Player 1's perspective. + timestep.info['eval_episode_return'] = -timestep.reward if timestep.obs[ + 'to_play'] == 1 else timestep.reward + return timestep + elif self.battle_mode == 'play_with_bot_mode': + # player 1 battle with expert player 2 + + # player 1's turn + timestep_player1 = self._player_step(action) + # print('player 1 (efficientzero player): ' + self.action_to_string(action)) # Note: visualize + if timestep_player1.done: + # in play_with_bot_mode, we set to_play as None/-1, because we don't consider the alternation between players + timestep_player1.obs['to_play'] = -1 + return timestep_player1 + + # player 2's turn + bot_action = self.bot_action() + # print('player 2 (expert player): ' + self.action_to_string(bot_action)) # Note: visualize + timestep_player2 = self._player_step(bot_action) + # self.render() # Note: visualize + # the eval_episode_return is calculated from Player 1's perspective + timestep_player2.info['eval_episode_return'] = -timestep_player2.reward + timestep_player2 = timestep_player2._replace(reward=-timestep_player2.reward) + + timestep = timestep_player2 + # NOTE: in play_with_bot_mode, we must set to_play as -1, because we don't consider the alternation between players. + # And the to_play is used in MCTS. + timestep.obs['to_play'] = -1 + return timestep + + elif self.battle_mode == 'eval_mode': + # player 1 battle with expert player 2 + + # player 1's turn + timestep_player1 = self._player_step(action) + if self.agent_vs_human: + print('player 1 (agent): ' + self.action_to_string(action)) # Note: visualize + self.render() + + if timestep_player1.done: + # in eval_mode, we set to_play as None/-1, because we don't consider the alternation between players + timestep_player1.obs['to_play'] = -1 + return timestep_player1 + + # player 2's turn + if self.agent_vs_human: + bot_action = self.human_to_action() + else: + bot_action = self.bot_action() + # bot_action = self.random_action() + + timestep_player2 = self._player_step(bot_action) + if self.agent_vs_human: + print('player 2 (human): ' + self.action_to_string(bot_action)) # Note: visualize + self.render() + + # the eval_episode_return is calculated from Player 1's perspective + timestep_player2.info['eval_episode_return'] = -timestep_player2.reward + timestep_player2 = timestep_player2._replace(reward=-timestep_player2.reward) + + timestep = timestep_player2 + # NOTE: in eval_mode, we must set to_play as -1, because we don't consider the alternation between players. + # And the to_play is used in MCTS. + timestep.obs['to_play'] = -1 + return timestep + + def get_done_winner(self): + """ + Overview: + Check if the game is over and who the winner is. Return 'done' and 'winner'. + Returns: + - outputs (:obj:`Tuple`): Tuple containing 'done' and 'winner', + - if player 1 win, 'done' = True, 'winner' = 1 + - if player 2 win, 'done' = True, 'winner' = 2 + - if draw, 'done' = True, 'winner' = -1 + - if game is not over, 'done' = False, 'winner' = -1 + """ + if self._raw_env._go.is_game_over(): + result = self._raw_env._go.result() + if result == 1: + return True, 1 + elif result == -1: + return True, 2 + elif result == 0: + return True, -1 + else: + return False, -1 def observe(self, agent): - player_plane = self._encode_player_plane(agent) + current_agent_plane, opponent_agent_plane = self._raw_env._encode_board_planes(agent) + player_plane = self._raw_env._encode_player_plane(agent) + observation = np.dstack((self.board_history, player_plane)) + legal_moves = self.next_legal_moves if agent == self.agent_selection else [] - action_mask = np.zeros((self._N * self._N) + 1, 'int8') + action_mask = np.zeros((self.board_size * self.board_size) + 1, "int8") for i in legal_moves: action_mask[i] = 1 - return {'observation': observation, 'action_mask': action_mask} + return {"observation": observation, "action_mask": action_mask} + def current_state(self): + """ + Overview: + self.board is nd-array, 0 indicates that no stones is placed here, + 1 indicates that player 1's stone is placed here, 2 indicates player 2's stone is placed here + Arguments: + - raw_obs (:obj:`array`): + the 0 dim means which positions is occupied by self.current_player, + the 1 dim indicates which positions are occupied by self.to_play, + the 2 dim indicates which player is the to_play player, 1 means player 1, 2 means player 2 + """ + if self.current_player == 1: + agent_id = 'black_0' + elif self.current_player == 2: + agent_id = 'white_0' + # obs = self._go.observe(agent_id) + # obs = self._raw_env.observe(agent_id) + obs = self.observe(agent_id) - def set_game_result(self, result_val): - for i, name in enumerate(self.agents): - self.dones[name] = True - result_coef = 1 if i == 0 else -1 - self.rewards[name] = result_val * result_coef - self.infos[name] = {'legal_moves': []} - def step(self, action): - if self.dones[self.agent_selection]: - return self._was_done_step(action) - self._go = self._go.play_move(coords.from_flat(action)) - self._last_obs = self.observe(self.agent_selection) - current_agent_plane, opponent_agent_plane = self._encode_board_planes(self.agent_selection) - self.board_history = np.dstack((current_agent_plane, opponent_agent_plane, self.board_history[:, :, :-2])) - next_player = self._agent_selector.next() - - current_agent = next_player # 'black_0', 'white_0' - current_index = self.agents.index(current_agent) # 0, 1 - self.current_player_index = current_index + obs['observation'] = obs['observation'].astype(int) + raw_obs = obs['observation'] - if self._go.is_game_over(): - self.dones = self._convert_to_dict([True for _ in range(self.num_agents)]) - self.rewards = self._convert_to_dict(self._encode_rewards(self._go.result())) - self.next_legal_moves = [self._N * self._N] + if self.channel_last: + # (W, H, C) (6, 6, 17) + return raw_obs, raw_obs else: - self.next_legal_moves = self._encode_legal_actions(self._go.all_legal_moves()) - self.agent_selection = next_player if next_player else self._agent_selector.next() - - # self._accumulate_rewards() - for agent, reward in self.rewards.items(): - self._cumulative_rewards[agent] += reward - # observation, reward, done, info = env.last() - agent = self.agent_selection - current_index = self.agents.index(agent) - self.current_player_index = current_index - observation = self.observe(agent) - return BaseEnvTimestep(observation, self._cumulative_rewards[agent], self.dones[agent], self.infos[agent]) + # move channel dim to first axis + # (W, H, C) -> (C, W, H) + # e.g. (6, 6, 17) - > (17, 6, 6) + return np.transpose(raw_obs, [2, 0, 1]), np.transpose(raw_obs, [2, 0, 1]) + @property def legal_actions(self): - pass + return self.legal_moves() def legal_moves(self): - if self._go.is_game_over(): - self.dones = self._convert_to_dict([True for _ in range(self.num_agents)]) - self.rewards = self._convert_to_dict(self._encode_rewards(self._go.result())) - self.next_legal_moves = [self._N * self._N] + if self._raw_env._go.is_game_over(): + self.terminations = self._convert_to_dict( + [True for _ in range(self.num_agents)] + ) + self.rewards = self._convert_to_dict( + self._encode_rewards(self._raw_env._go.result()) + ) + self.next_legal_moves = [self.board_size * self.board_size] else: - self.next_legal_moves = self._encode_legal_actions(self._go.all_legal_moves()) + self.next_legal_moves = self._encode_legal_actions(self._raw_env._go.all_legal_moves()) return self.next_legal_moves def random_action(self): - action_list = self.legal_moves() - return np.random.choice(action_list) + return np.random.choice(self.legal_actions) def bot_action(self): - # TODO - pass + return self.random_action() def human_to_action(self): """ @@ -234,20 +451,24 @@ def human_to_action(self): return choice def render(self, mode='human'): + if mode == "board": + print(self._raw_env._go.board) + return + screen_width = 1026 screen_height = 1026 if self.screen is None: if mode == "human": pygame.init() + pygame.display.init() self.screen = pygame.display.set_mode((screen_width, screen_height)) else: self.screen = pygame.Surface((screen_width, screen_height)) if mode == "human": pygame.event.get() - size = go.N - + size = self.board_size # Load and scale all of the necessary images tile_size = (screen_width) / size @@ -287,12 +508,14 @@ def render(self, mode='human'): self.screen.blit(tile_img, (0, (size - 1) * (tile_size))) offset = tile_size * (1 / 6) + board_tmp = np.transpose(self._raw_env._go.board) + # Blit the necessary chips and their positions for i in range(0, size): for j in range(0, size): - if self._go.board[i][j] == go.BLACK: + if board_tmp[i][j] == go_base.BLACK: self.screen.blit(black_stone, ((i * (tile_size) + offset), int(j) * (tile_size) + offset)) - elif self._go.board[i][j] == go.WHITE: + elif board_tmp[i][j] == go_base.WHITE: self.screen.blit(white_stone, ((i * (tile_size) + offset), int(j) * (tile_size) + offset)) if mode == "human": @@ -302,19 +525,81 @@ def render(self, mode='human'): return np.transpose(observation, axes=(1, 0, 2)) if mode == "rgb_array" else None - def observation_space(self): - return self.observation_spaces + # def observation_space(self): + # return self.observation_spaces + # + # def action_space(self): + # return self._action_space - def action_space(self): - return self._action_space + def _check_bounds(self, c): + return 0 <= c[0] < self.board_size and 0 <= c[1] < self.board_size + + def _encode_player_plane(self, agent): + if agent == self.possible_agents[0]: + return np.zeros([self.board_size, self.board_size], dtype=bool) + else: + return np.ones([self.board_size, self.board_size], dtype=bool) + + def _int_to_name(self, ind): + return self.possible_agents[ind] + + def _name_to_int(self, name): + return self.possible_agents.index(name) + + def _convert_to_dict(self, list_of_list): + return dict(zip(self.possible_agents, list_of_list)) + + def _encode_legal_actions(self, actions): + return np.where(actions == 1)[0] + + def _encode_rewards(self, result): + return [1, -1] if result == 1 else [-1, 1] + + def set_game_result(self, result_val): + for i, name in enumerate(self.agents): + self.dones[name] = True + result_coef = 1 if i == 0 else -1 + self.rewards[name] = result_val * result_coef + self.infos[name] = {'legal_moves': []} def seed(self, seed: int, dynamic_seed: bool = True) -> None: self._seed = seed self._dynamic_seed = dynamic_seed np.random.seed(self._seed) - def close(self) -> None: - pass + @property + def observation_space(self) -> gym.spaces.Space: + return self._observation_space + + @property + def action_space(self) -> gym.spaces.Space: + return self._action_space + + @property + def reward_space(self) -> gym.spaces.Space: + return self._reward_space + + @current_player.setter + def current_player(self, value): + self._current_player = value + + @staticmethod + def create_collector_env_cfg(cfg: dict) -> List[dict]: + collector_env_num = cfg.pop('collector_env_num') + cfg = copy.deepcopy(cfg) + return [cfg for _ in range(collector_env_num)] + + @staticmethod + def create_evaluator_env_cfg(cfg: dict) -> List[dict]: + evaluator_env_num = cfg.pop('evaluator_env_num') + cfg = copy.deepcopy(cfg) + # In eval phase, we use ``eval_mode`` to make agent play with the built-in bot to + # evaluate the performance of the current agent. + cfg.battle_mode = 'eval_mode' + return [cfg for _ in range(evaluator_env_num)] def __repr__(self) -> str: return "LightZero Go Env" + + def close(self) -> None: + pass diff --git a/zoo/board_games/go/envs/go_env_bkp.py b/zoo/board_games/go/envs/go_env_bkp.py new file mode 100644 index 000000000..6b3f07f54 --- /dev/null +++ b/zoo/board_games/go/envs/go_env_bkp.py @@ -0,0 +1,330 @@ +import os +import sys + +import numpy as np +import pygame +from ding.envs import BaseEnv, BaseEnvTimestep +from ding.utils import ENV_REGISTRY +from gym import spaces +from pettingzoo.classic.go import coords, go +from pettingzoo.utils.agent_selector import agent_selector + + +def get_image(path): + from os import path as os_path + + import pygame + cwd = os_path.dirname(__file__) + image = pygame.image.load(cwd + '/' + path) + sfc = pygame.Surface(image.get_size(), flags=pygame.SRCALPHA) + sfc.blit(image, (0, 0)) + return sfc + + +@ENV_REGISTRY.register('Go') +class GoEnv(BaseEnv): + + def __init__(self, board_size: int = 19, komi: float = 7.5): + # board_size: a int, representing the board size (board has a board_size x board_size shape) + # komi: a float, representing points given to the second player. + # self._overwrite_go_global_variables(board_size=board_size) + self._komi = komi + self.board_size = board_size + self._N = board_size + self.agents = ['black_0', 'white_0'] + self.num_agents = len(self.agents) + + self.possible_agents = self.agents[:] + self.has_reset = False + + self.screen = None + + self._observation_space = self._convert_to_dict( + [ + spaces.Dict( + { + 'observation': spaces.Box(low=0, high=1, shape=(self._N, self._N, 17), dtype=bool), + 'action_mask': spaces.Box(low=0, high=1, shape=((self._N * self._N) + 1, ), dtype=np.int8) + } + ) for _ in range(self.num_agents) + ] + ) + + self._action_space = self._convert_to_dict( + [spaces.Discrete(self._N * self._N + 1) for _ in range(self.num_agents)] + ) + + self._agent_selector = agent_selector(self.agents) + + self.board_history = np.zeros((self._N, self._N, 16), dtype=bool) + + def reset(self): + self.has_reset = True + # self._go = go.Position(board=None, komi=self._komi) + # self._go = go.go_base.Position(board=None, komi=self._komi) + # self._go = go.step(board=None, komi=self._komi) + # self._go._overwrite_go_global_variables(board_size=self.board_size) + # self._overwrite_go_global_variables(board_size=self.board_size) + + # self._go = go.env(board_size=self.board_size, komi=self._komi) + from pettingzoo.classic import go_v5 + self._go = go_v5.env(board_size=self.board_size, komi=self._komi) + + self.agents = self.possible_agents[:] + self._agent_selector.reinit(self.agents) + self.agent_selection = self._agent_selector.reset() + self._cumulative_rewards = self._convert_to_dict(np.array([0.0, 0.0])) + self.rewards = self._convert_to_dict(np.array([0.0, 0.0])) + self.dones = self._convert_to_dict([False for _ in range(self.num_agents)]) + self.infos = self._convert_to_dict([{} for _ in range(self.num_agents)]) + # self.next_legal_moves = self._encode_legal_actions(self._go.all_legal_moves()) + self._last_obs = self.observe(self.agents[0]) + self.board_history = np.zeros((self._N, self._N, 16), dtype=bool) + + self.current_player_index = 0 + + for agent, reward in self.rewards.items(): + self._cumulative_rewards[agent] += reward + + agent = self.agent_selection + current_index = self.agents.index(agent) + self.current_player_index = current_index + obs = self.observe(agent) + return obs + + def step(self, action): + if self.dones[self.agent_selection]: + return self._was_done_step(action) + self._go = self._go.play_move(coords.from_flat(action)) + self._last_obs = self.observe(self.agent_selection) + current_agent_plane, opponent_agent_plane = self._encode_board_planes(self.agent_selection) + self.board_history = np.dstack((current_agent_plane, opponent_agent_plane, self.board_history[:, :, :-2])) + next_player = self._agent_selector.next() + + current_agent = next_player # 'black_0', 'white_0' + current_index = self.agents.index(current_agent) # 0, 1 + self.current_player_index = current_index + + if self._go.is_game_over(): + self.dones = self._convert_to_dict([True for _ in range(self.num_agents)]) + self.rewards = self._convert_to_dict(self._encode_rewards(self._go.result())) + self.next_legal_moves = [self._N * self._N] + else: + self.next_legal_moves = self._encode_legal_actions(self._go.all_legal_moves()) + self.agent_selection = next_player if next_player else self._agent_selector.next() + + # self._accumulate_rewards() + for agent, reward in self.rewards.items(): + self._cumulative_rewards[agent] += reward + # observation, reward, done, info = env.last() + agent = self.agent_selection + current_index = self.agents.index(agent) + self.current_player_index = current_index + observation = self.observe(agent) + return BaseEnvTimestep(observation, self._cumulative_rewards[agent], self.dones[agent], self.infos[agent]) + + def _overwrite_go_global_variables(self, board_size: int): + # self._N = board_size + # go.N = self._N + # go.ALL_COORDS = [(i, j) for i in range(self._N) for j in range(self._N)] + # go.EMPTY_BOARD = np.zeros([self._N, self._N], dtype=np.int8) + # go.NEIGHBORS = { + # (x, y): list(filter(self._check_bounds, [(x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)])) + # for x, y in go.ALL_COORDS + # } + # go.DIAGONALS = { + # (x, y): list(filter(self._check_bounds, [(x + 1, y + 1), (x + 1, y - 1), (x - 1, y + 1), (x - 1, y - 1)])) + # for x, y in go.ALL_COORDS + # } + # return + self._go._overwrite_go_global_variables(board_size) + + def _check_bounds(self, c): + return 0 <= c[0] < self._N and 0 <= c[1] < self._N + + def _encode_player_plane(self, agent): + if agent == self.possible_agents[0]: + return np.zeros([self._N, self._N], dtype=bool) + else: + return np.ones([self._N, self._N], dtype=bool) + + def _encode_board_planes(self, agent): + agent_factor = go.BLACK if agent == self.possible_agents[0] else go.WHITE + current_agent_plane_idx = np.where(self._go.board == agent_factor) + opponent_agent_plane_idx = np.where(self._go.board == -agent_factor) + current_agent_plane = np.zeros([self._N, self._N], dtype=bool) + opponent_agent_plane = np.zeros([self._N, self._N], dtype=bool) + current_agent_plane[current_agent_plane_idx] = 1 + opponent_agent_plane[opponent_agent_plane_idx] = 1 + return current_agent_plane, opponent_agent_plane + + def _int_to_name(self, ind): + return self.possible_agents[ind] + + def _name_to_int(self, name): + return self.possible_agents.index(name) + + def _convert_to_dict(self, list_of_list): + return dict(zip(self.possible_agents, list_of_list)) + + def _encode_legal_actions(self, actions): + return np.where(actions == 1)[0] + + def _encode_rewards(self, result): + return [1, -1] if result == 1 else [-1, 1] + + @property + def current_player(self): + return self.current_player_index + + @property + def to_play(self): + return self.current_player_index + + + + def observe(self, agent): + player_plane = self._encode_player_plane(agent) + observation = np.dstack((self.board_history, player_plane)) + legal_moves = self.next_legal_moves if agent == self.agent_selection else [] + action_mask = np.zeros((self._N * self._N) + 1, 'int8') + for i in legal_moves: + action_mask[i] = 1 + + return {'observation': observation, 'action_mask': action_mask} + + def set_game_result(self, result_val): + for i, name in enumerate(self.agents): + self.dones[name] = True + result_coef = 1 if i == 0 else -1 + self.rewards[name] = result_val * result_coef + self.infos[name] = {'legal_moves': []} + + + def legal_actions(self): + pass + + def legal_moves(self): + if self._go.is_game_over(): + self.dones = self._convert_to_dict([True for _ in range(self.num_agents)]) + self.rewards = self._convert_to_dict(self._encode_rewards(self._go.result())) + self.next_legal_moves = [self._N * self._N] + else: + self.next_legal_moves = self._encode_legal_actions(self._go.all_legal_moves()) + + return self.next_legal_moves + + def random_action(self): + action_list = self.legal_moves() + return np.random.choice(action_list) + + def bot_action(self): + # TODO + pass + + def human_to_action(self): + """ + Overview: + For multiplayer games, ask the user for a legal action + and return the corresponding action number. + Returns: + An integer from the action space. + """ + # print(self.board) + while True: + try: + print(f"Current available actions for the player {self.to_play()} are:{self.legal_moves()}") + choice = int(input(f"Enter the index of next move for the player {self.to_play()}: ")) + if choice in self.legal_moves(): + break + except KeyboardInterrupt: + sys.exit(0) + except Exception as e: + print("Wrong input, try again") + return choice + + def render(self, mode='human'): + screen_width = 1026 + screen_height = 1026 + + if self.screen is None: + if mode == "human": + pygame.init() + self.screen = pygame.display.set_mode((screen_width, screen_height)) + else: + self.screen = pygame.Surface((screen_width, screen_height)) + if mode == "human": + pygame.event.get() + + size = go.N + + # Load and scale all of the necessary images + tile_size = (screen_width) / size + + black_stone = get_image(os.path.join('../img', 'GoBlackPiece.png')) + black_stone = pygame.transform.scale(black_stone, (int(tile_size * (5 / 6)), int(tile_size * (5 / 6)))) + + white_stone = get_image(os.path.join('../img', 'GoWhitePiece.png')) + white_stone = pygame.transform.scale(white_stone, (int(tile_size * (5 / 6)), int(tile_size * (5 / 6)))) + + tile_img = get_image(os.path.join('../img', 'GO_Tile0.png')) + tile_img = pygame.transform.scale(tile_img, ((int(tile_size * (7 / 6))), int(tile_size * (7 / 6)))) + + # blit board tiles + for i in range(1, size - 1): + for j in range(1, size - 1): + self.screen.blit(tile_img, ((i * (tile_size)), int(j) * (tile_size))) + + for i in range(1, 9): + tile_img = get_image(os.path.join('../img', 'GO_Tile' + str(i) + '.png')) + tile_img = pygame.transform.scale(tile_img, ((int(tile_size * (7 / 6))), int(tile_size * (7 / 6)))) + for j in range(1, size - 1): + if i == 1: + self.screen.blit(tile_img, (0, int(j) * (tile_size))) + elif i == 2: + self.screen.blit(tile_img, ((int(j) * (tile_size)), 0)) + elif i == 3: + self.screen.blit(tile_img, ((size - 1) * (tile_size), int(j) * (tile_size))) + elif i == 4: + self.screen.blit(tile_img, ((int(j) * (tile_size)), (size - 1) * (tile_size))) + if i == 5: + self.screen.blit(tile_img, (0, 0)) + elif i == 6: + self.screen.blit(tile_img, ((size - 1) * (tile_size), 0)) + elif i == 7: + self.screen.blit(tile_img, ((size - 1) * (tile_size), (size - 1) * (tile_size))) + elif i == 8: + self.screen.blit(tile_img, (0, (size - 1) * (tile_size))) + + offset = tile_size * (1 / 6) + # Blit the necessary chips and their positions + for i in range(0, size): + for j in range(0, size): + if self._go.board[i][j] == go.BLACK: + self.screen.blit(black_stone, ((i * (tile_size) + offset), int(j) * (tile_size) + offset)) + elif self._go.board[i][j] == go.WHITE: + self.screen.blit(white_stone, ((i * (tile_size) + offset), int(j) * (tile_size) + offset)) + + if mode == "human": + pygame.display.update() + + observation = np.array(pygame.surfarray.pixels3d(self.screen)) + + return np.transpose(observation, axes=(1, 0, 2)) if mode == "rgb_array" else None + + def observation_space(self): + return self.observation_spaces + + def action_space(self): + return self._action_space + + def seed(self, seed: int, dynamic_seed: bool = True) -> None: + self._seed = seed + self._dynamic_seed = dynamic_seed + np.random.seed(self._seed) + + def close(self) -> None: + pass + + def __repr__(self) -> str: + return "LightZero Go Env" diff --git a/zoo/board_games/go/envs/test_go_env.py b/zoo/board_games/go/envs/test_go_env.py index e1a2e672e..48b1f26f0 100644 --- a/zoo/board_games/go/envs/test_go_env.py +++ b/zoo/board_games/go/envs/test_go_env.py @@ -1,40 +1,80 @@ import pytest +from easydict import EasyDict from zoo.board_games.go.envs.go_env import GoEnv +import time +cfg = EasyDict( + board_size=6, + komi=7.5, + battle_mode='self_play_mode', + prob_random_agent=0, + channel_last=False, + scale=True, + agent_vs_human=False, + bot_action_type='v0', + prob_random_action_in_bot=0., + check_action_to_connect4_in_bot_v0=False, + stop_value=1, +) @pytest.mark.envtest class TestGoEnv: def test_naive(self): - env = GoEnv(board_size=9, komi=7.5) + + env = GoEnv(cfg) print('NOTE：actions are counted by column, such as action 9, which is the second column and the first row') - env.reset() + obs = env.reset() + print(obs['observation'].shape, obs['action_mask'].shape) + print(obs['observation'], obs['action_mask']) + + actions_black = [0, 2, 0] + actions_white = [1, 6] # env.render() - for i in range(100): + for i in range(1000): + print('turn: ', i) """player 1""" # action = env.human_to_action() - action = env.random_action() + # action = env.random_action() + + action = actions_black[i] print('player 1 (black_0): ', action) obs, reward, done, info = env.step(action) + # time.sleep(0.1) + + # print(obs, reward, done, info) assert isinstance(obs, dict) assert isinstance(done, bool) assert isinstance(reward, float) - # env.render() + # env.render('board') + env.render('human') + if done: if reward > 0: print('player 1 (black_0) win') + elif reward < 0: + print('player 2 (white_0) win') else: print('draw') break + """player 2""" - action = env.random_action() + # action = env.random_action() + + action = actions_white[i] print('player 2 (white_0): ', action) obs, reward, done, info = env.step(action) - # env.render() + # time.sleep(0.1) + + # print(obs, reward, done, info) + # env.render('board') + env.render('human') if done: if reward > 0: print('player 2 (white_0) win') + elif reward < 0: + print('player 1 (black_0) win') else: print('draw') break diff --git a/zoo/board_games/gomoku/config/gomoku_alphazero_bot_mode_config.py b/zoo/board_games/gomoku/config/gomoku_alphazero_bot_mode_config.py index 5aa9c4abe..1cac41cc2 100644 --- a/zoo/board_games/gomoku/config/gomoku_alphazero_bot_mode_config.py +++ b/zoo/board_games/gomoku/config/gomoku_alphazero_bot_mode_config.py @@ -42,7 +42,7 @@ board_size=board_size, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, grad_clip_value=0.5, diff --git a/zoo/board_games/gomoku/config/gomoku_alphazero_sp_mode_config.py b/zoo/board_games/gomoku/config/gomoku_alphazero_sp_mode_config.py index 2ca4da3ad..e9c30bc0f 100644 --- a/zoo/board_games/gomoku/config/gomoku_alphazero_sp_mode_config.py +++ b/zoo/board_games/gomoku/config/gomoku_alphazero_sp_mode_config.py @@ -42,7 +42,7 @@ board_size=board_size, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, manual_temperature_decay=True, diff --git a/zoo/board_games/gomoku/config/gomoku_gumbel_muzero_bot_mode_config.py b/zoo/board_games/gomoku/config/gomoku_gumbel_muzero_bot_mode_config.py index cdecb0f50..bfba1dd6d 100644 --- a/zoo/board_games/gomoku/config/gomoku_gumbel_muzero_bot_mode_config.py +++ b/zoo/board_games/gomoku/config/gomoku_gumbel_muzero_bot_mode_config.py @@ -49,7 +49,7 @@ game_segment_length=int(board_size * board_size / 2), # for battle_mode='play_with_bot_mode' update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, grad_clip_value=0.5, diff --git a/zoo/board_games/gomoku/config/gomoku_muzero_bot_mode_config.py b/zoo/board_games/gomoku/config/gomoku_muzero_bot_mode_config.py index ef0c87000..06a40e342 100644 --- a/zoo/board_games/gomoku/config/gomoku_muzero_bot_mode_config.py +++ b/zoo/board_games/gomoku/config/gomoku_muzero_bot_mode_config.py @@ -49,7 +49,7 @@ game_segment_length=int(board_size * board_size / 2), # for battle_mode='play_with_bot_mode' update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, grad_clip_value=0.5, diff --git a/zoo/board_games/gomoku/config/gomoku_muzero_sp_mode_config.py b/zoo/board_games/gomoku/config/gomoku_muzero_sp_mode_config.py index 97e8cd9b2..3e60e37d6 100644 --- a/zoo/board_games/gomoku/config/gomoku_muzero_sp_mode_config.py +++ b/zoo/board_games/gomoku/config/gomoku_muzero_sp_mode_config.py @@ -48,7 +48,7 @@ game_segment_length=int(board_size * board_size), # for battle_mode='self_play_mode' update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, grad_clip_value=0.5, diff --git a/zoo/board_games/tictactoe/config/tictactoe_alphazero_bot_mode_config.py b/zoo/board_games/tictactoe/config/tictactoe_alphazero_bot_mode_config.py index 06c29561a..768d3804a 100644 --- a/zoo/board_games/tictactoe/config/tictactoe_alphazero_bot_mode_config.py +++ b/zoo/board_games/tictactoe/config/tictactoe_alphazero_bot_mode_config.py @@ -39,7 +39,7 @@ board_size=3, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, grad_clip_value=0.5, diff --git a/zoo/board_games/tictactoe/config/tictactoe_alphazero_sp_mode_config.py b/zoo/board_games/tictactoe/config/tictactoe_alphazero_sp_mode_config.py index a56c10bc9..efff341d1 100644 --- a/zoo/board_games/tictactoe/config/tictactoe_alphazero_sp_mode_config.py +++ b/zoo/board_games/tictactoe/config/tictactoe_alphazero_sp_mode_config.py @@ -38,7 +38,7 @@ board_size=3, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, grad_clip_value=0.5, diff --git a/zoo/board_games/tictactoe/config/tictactoe_gumbel_muzero_bot_mode_config.py b/zoo/board_games/tictactoe/config/tictactoe_gumbel_muzero_bot_mode_config.py index d2bc056c6..e1b74f4d0 100644 --- a/zoo/board_games/tictactoe/config/tictactoe_gumbel_muzero_bot_mode_config.py +++ b/zoo/board_games/tictactoe/config/tictactoe_gumbel_muzero_bot_mode_config.py @@ -45,7 +45,7 @@ game_segment_length=5, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, grad_clip_value=0.5, diff --git a/zoo/board_games/tictactoe/config/tictactoe_muzero_bot_mode_config.py b/zoo/board_games/tictactoe/config/tictactoe_muzero_bot_mode_config.py index 41b5a681c..e292fc141 100644 --- a/zoo/board_games/tictactoe/config/tictactoe_muzero_bot_mode_config.py +++ b/zoo/board_games/tictactoe/config/tictactoe_muzero_bot_mode_config.py @@ -46,7 +46,7 @@ game_segment_length=5, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, grad_clip_value=0.5, diff --git a/zoo/board_games/tictactoe/config/tictactoe_muzero_sp_mode_config.py b/zoo/board_games/tictactoe/config/tictactoe_muzero_sp_mode_config.py index 4f8bdb594..c75837c88 100644 --- a/zoo/board_games/tictactoe/config/tictactoe_muzero_sp_mode_config.py +++ b/zoo/board_games/tictactoe/config/tictactoe_muzero_sp_mode_config.py @@ -45,7 +45,7 @@ game_segment_length=9, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, grad_clip_value=0.5, diff --git a/zoo/board_games/tictactoe/envs/tictactoe_env.py b/zoo/board_games/tictactoe/envs/tictactoe_env.py index b5afc9f14..01ef5d17f 100644 --- a/zoo/board_games/tictactoe/envs/tictactoe_env.py +++ b/zoo/board_games/tictactoe/envs/tictactoe_env.py @@ -94,6 +94,16 @@ def legal_actions_cython_lru(self): return _legal_actions_func_lru(tuple(map(tuple, self.board))) def get_done_winner(self): + """ + Overview: + Check if the game is over and who the winner is. Return 'done' and 'winner'. + Returns: + - outputs (:obj:`Tuple`): Tuple containing 'done' and 'winner', + - if player 1 win, 'done' = True, 'winner' = 1 + - if player 2 win, 'done' = True, 'winner' = 2 + - if draw, 'done' = True, 'winner' = -1 + - if game is not over, 'done' = False, 'winner' = -1 + """ # Convert NumPy arrays to nested tuples to make them hashable. return _get_done_winner_func_lru(tuple(map(tuple, self.board))) diff --git a/zoo/box2d/bipedalwalker/config/bipedalwalker_cont_disc_efficientzero_config.py b/zoo/box2d/bipedalwalker/config/bipedalwalker_cont_disc_efficientzero_config.py index dfd7effbd..92e3ad0b7 100644 --- a/zoo/box2d/bipedalwalker/config/bipedalwalker_cont_disc_efficientzero_config.py +++ b/zoo/box2d/bipedalwalker/config/bipedalwalker_cont_disc_efficientzero_config.py @@ -48,7 +48,7 @@ game_segment_length=200, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, # NOTE: this parameter is important for stability in bipedalwalker. diff --git a/zoo/box2d/bipedalwalker/config/bipedalwalker_cont_disc_sampled_efficientzero_config.py b/zoo/box2d/bipedalwalker/config/bipedalwalker_cont_disc_sampled_efficientzero_config.py index 098fc3adb..6f1172b8a 100644 --- a/zoo/box2d/bipedalwalker/config/bipedalwalker_cont_disc_sampled_efficientzero_config.py +++ b/zoo/box2d/bipedalwalker/config/bipedalwalker_cont_disc_sampled_efficientzero_config.py @@ -50,7 +50,7 @@ game_segment_length=200, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, # NOTE: this parameter is important for stability in bipedalwalker. diff --git a/zoo/box2d/bipedalwalker/config/bipedalwalker_cont_sampled_efficientzero_config.py b/zoo/box2d/bipedalwalker/config/bipedalwalker_cont_sampled_efficientzero_config.py index de91757f5..dff763b32 100644 --- a/zoo/box2d/bipedalwalker/config/bipedalwalker_cont_sampled_efficientzero_config.py +++ b/zoo/box2d/bipedalwalker/config/bipedalwalker_cont_sampled_efficientzero_config.py @@ -48,7 +48,7 @@ game_segment_length=200, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, # NOTE: this parameter is important for stability in bipedalwalker. diff --git a/zoo/box2d/lunarlander/config/lunarlander_cont_disc_efficientzero_config.py b/zoo/box2d/lunarlander/config/lunarlander_cont_disc_efficientzero_config.py index c05304480..981c0c921 100644 --- a/zoo/box2d/lunarlander/config/lunarlander_cont_disc_efficientzero_config.py +++ b/zoo/box2d/lunarlander/config/lunarlander_cont_disc_efficientzero_config.py @@ -49,7 +49,7 @@ game_segment_length=200, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, num_simulations=num_simulations, diff --git a/zoo/box2d/lunarlander/config/lunarlander_cont_disc_sampled_efficientzero_config.py b/zoo/box2d/lunarlander/config/lunarlander_cont_disc_sampled_efficientzero_config.py index d10e8b3b7..59f679ee8 100644 --- a/zoo/box2d/lunarlander/config/lunarlander_cont_disc_sampled_efficientzero_config.py +++ b/zoo/box2d/lunarlander/config/lunarlander_cont_disc_sampled_efficientzero_config.py @@ -51,7 +51,7 @@ game_segment_length=200, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, num_simulations=num_simulations, diff --git a/zoo/box2d/lunarlander/config/lunarlander_cont_sampled_efficientzero_config.py b/zoo/box2d/lunarlander/config/lunarlander_cont_sampled_efficientzero_config.py index 74c02b970..750c36d2d 100644 --- a/zoo/box2d/lunarlander/config/lunarlander_cont_sampled_efficientzero_config.py +++ b/zoo/box2d/lunarlander/config/lunarlander_cont_sampled_efficientzero_config.py @@ -47,7 +47,7 @@ game_segment_length=200, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, grad_clip_value=0.5, diff --git a/zoo/box2d/lunarlander/config/lunarlander_disc_efficientzero_config.py b/zoo/box2d/lunarlander/config/lunarlander_disc_efficientzero_config.py index 2efbebe6b..ac4e50136 100644 --- a/zoo/box2d/lunarlander/config/lunarlander_disc_efficientzero_config.py +++ b/zoo/box2d/lunarlander/config/lunarlander_disc_efficientzero_config.py @@ -43,7 +43,7 @@ game_segment_length=200, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, grad_clip_value=0.5, diff --git a/zoo/box2d/lunarlander/config/lunarlander_disc_gumbel_muzero_config.py b/zoo/box2d/lunarlander/config/lunarlander_disc_gumbel_muzero_config.py index 54767af7c..7a487f9c1 100644 --- a/zoo/box2d/lunarlander/config/lunarlander_disc_gumbel_muzero_config.py +++ b/zoo/box2d/lunarlander/config/lunarlander_disc_gumbel_muzero_config.py @@ -43,7 +43,7 @@ game_segment_length=200, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', max_num_considered_actions=4, lr_piecewise_constant_decay=False, learning_rate=0.003, diff --git a/zoo/box2d/lunarlander/config/lunarlander_disc_muzero_config.py b/zoo/box2d/lunarlander/config/lunarlander_disc_muzero_config.py index b3229b63b..210d6237c 100644 --- a/zoo/box2d/lunarlander/config/lunarlander_disc_muzero_config.py +++ b/zoo/box2d/lunarlander/config/lunarlander_disc_muzero_config.py @@ -43,7 +43,7 @@ game_segment_length=200, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, ssl_loss_weight=2, # NOTE: default is 0. diff --git a/zoo/classic_control/cartpole/config/cartpole_efficientzero_config.py b/zoo/classic_control/cartpole/config/cartpole_efficientzero_config.py index 95dc2fa17..a9d3134a3 100644 --- a/zoo/classic_control/cartpole/config/cartpole_efficientzero_config.py +++ b/zoo/classic_control/cartpole/config/cartpole_efficientzero_config.py @@ -42,7 +42,7 @@ game_segment_length=50, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, num_simulations=num_simulations, diff --git a/zoo/classic_control/cartpole/config/cartpole_gumbel_muzero_config.py b/zoo/classic_control/cartpole/config/cartpole_gumbel_muzero_config.py index 5e86a5831..762b65b57 100644 --- a/zoo/classic_control/cartpole/config/cartpole_gumbel_muzero_config.py +++ b/zoo/classic_control/cartpole/config/cartpole_gumbel_muzero_config.py @@ -42,7 +42,7 @@ game_segment_length=50, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', max_num_considered_actions=2, lr_piecewise_constant_decay=False, learning_rate=0.003, diff --git a/zoo/classic_control/cartpole/config/cartpole_muzero_config.py b/zoo/classic_control/cartpole/config/cartpole_muzero_config.py index 8bfd87d5a..c25dfcb52 100644 --- a/zoo/classic_control/cartpole/config/cartpole_muzero_config.py +++ b/zoo/classic_control/cartpole/config/cartpole_muzero_config.py @@ -42,7 +42,7 @@ game_segment_length=50, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, ssl_loss_weight=2, # NOTE: default is 0. diff --git a/zoo/classic_control/cartpole/config/cartpole_sampled_efficientzero_config.py b/zoo/classic_control/cartpole/config/cartpole_sampled_efficientzero_config.py index 7f9822bd6..79dc23cd7 100644 --- a/zoo/classic_control/cartpole/config/cartpole_sampled_efficientzero_config.py +++ b/zoo/classic_control/cartpole/config/cartpole_sampled_efficientzero_config.py @@ -46,7 +46,7 @@ game_segment_length=50, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, num_simulations=num_simulations, diff --git a/zoo/classic_control/pendulum/config/pendulum_cont_disc_efficientzero_config.py b/zoo/classic_control/pendulum/config/pendulum_cont_disc_efficientzero_config.py index d239e87d6..119601cc2 100644 --- a/zoo/classic_control/pendulum/config/pendulum_cont_disc_efficientzero_config.py +++ b/zoo/classic_control/pendulum/config/pendulum_cont_disc_efficientzero_config.py @@ -41,7 +41,7 @@ game_segment_length=50, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, num_simulations=num_simulations, diff --git a/zoo/classic_control/pendulum/config/pendulum_cont_disc_muzero_config.py b/zoo/classic_control/pendulum/config/pendulum_cont_disc_muzero_config.py index 0d1e4f879..f6942f5f0 100644 --- a/zoo/classic_control/pendulum/config/pendulum_cont_disc_muzero_config.py +++ b/zoo/classic_control/pendulum/config/pendulum_cont_disc_muzero_config.py @@ -45,7 +45,7 @@ game_segment_length=50, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, ssl_loss_weight=2, # NOTE: default is 0. diff --git a/zoo/classic_control/pendulum/config/pendulum_cont_disc_sampled_efficientzero_config.py b/zoo/classic_control/pendulum/config/pendulum_cont_disc_sampled_efficientzero_config.py index f7c74437c..4c62cdb01 100644 --- a/zoo/classic_control/pendulum/config/pendulum_cont_disc_sampled_efficientzero_config.py +++ b/zoo/classic_control/pendulum/config/pendulum_cont_disc_sampled_efficientzero_config.py @@ -45,7 +45,7 @@ game_segment_length=50, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, num_simulations=num_simulations, diff --git a/zoo/classic_control/pendulum/config/pendulum_cont_sampled_efficientzero_config.py b/zoo/classic_control/pendulum/config/pendulum_cont_sampled_efficientzero_config.py index 5712af84c..71e775ed4 100644 --- a/zoo/classic_control/pendulum/config/pendulum_cont_sampled_efficientzero_config.py +++ b/zoo/classic_control/pendulum/config/pendulum_cont_sampled_efficientzero_config.py @@ -45,7 +45,7 @@ game_segment_length=50, update_per_collect=update_per_collect, batch_size=batch_size, - optim_type='Adam', + optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, # NOTE: for continuous gaussian policy, we use the policy_entropy_loss as in the original Sampled MuZero paper. From aa41a55d8d660b8c77a0ced4cfac854b20917824 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Sat, 24 Jun 2023 17:13:31 +0800 Subject: [PATCH 14/34] feature(pu): add init version of go muzero config --- .../go/config/go_alphazero_bot_mode_config.py | 6 +- .../go/config/go_alphazero_sp_mode_config.py | 38 +++---- .../go/config/go_muzero_bot_mode_config.py | 100 +++++++++++++++++ .../go/config/go_muzero_eval_config.py | 43 ++++++++ .../go/config/go_muzero_sp_mode_config.py | 102 ++++++++++++++++++ zoo/board_games/go/envs/go_env.py | 4 - 6 files changed, 268 insertions(+), 25 deletions(-) create mode 100644 zoo/board_games/go/config/go_muzero_bot_mode_config.py create mode 100644 zoo/board_games/go/config/go_muzero_eval_config.py create mode 100644 zoo/board_games/go/config/go_muzero_sp_mode_config.py diff --git a/zoo/board_games/go/config/go_alphazero_bot_mode_config.py b/zoo/board_games/go/config/go_alphazero_bot_mode_config.py index 1cac41cc2..003e00403 100644 --- a/zoo/board_games/go/config/go_alphazero_bot_mode_config.py +++ b/zoo/board_games/go/config/go_alphazero_bot_mode_config.py @@ -23,7 +23,7 @@ battle_mode='play_with_bot_mode', bot_action_type='v0', prob_random_action_in_bot=prob_random_action_in_bot, - channel_last=False, # NOTE + channel_last=True, collector_env_num=collector_env_num, evaluator_env_num=evaluator_env_num, n_evaluator_episode=evaluator_env_num, @@ -33,8 +33,8 @@ torch_compile=False, tensor_float_32=False, model=dict( - observation_shape=(3, board_size, board_size), - action_space_size=int(1 * board_size * board_size), + observation_shape=(board_size, board_size, 17), + action_space_size=int(1 * board_size * board_size + 1), num_res_blocks=1, num_channels=32, ), diff --git a/zoo/board_games/go/config/go_alphazero_sp_mode_config.py b/zoo/board_games/go/config/go_alphazero_sp_mode_config.py index 39fe2bca0..6a61730a2 100644 --- a/zoo/board_games/go/config/go_alphazero_sp_mode_config.py +++ b/zoo/board_games/go/config/go_alphazero_sp_mode_config.py @@ -1,27 +1,28 @@ from easydict import EasyDict + # ============================================================== # begin of the most frequently changed config specified by the user # ============================================================== -board_size = 6 # default_size is 15 -collector_env_num = 32 -n_episode = 32 -evaluator_env_num = 5 -num_simulations = 50 -update_per_collect = 50 -batch_size = 256 +# board_size = 6 +# collector_env_num = 32 +# n_episode = 32 +# evaluator_env_num = 5 +# num_simulations = 50 +# update_per_collect = 50 +# batch_size = 256 +# max_env_step = int(1e6) +# prob_random_action_in_bot = 1 + +board_size = 6 +collector_env_num = 1 +n_episode = 1 +evaluator_env_num = 1 +num_simulations = 2 +update_per_collect = 2 +batch_size = 2 max_env_step = int(5e5) prob_random_action_in_bot = 0. - -# board_size = 6 # default_size is 15 -# collector_env_num = 1 -# n_episode = 1 -# evaluator_env_num = 1 -# num_simulations = 2 -# update_per_collect = 2 -# batch_size = 2 -# max_env_step = int(5e5) -# prob_random_action_in_bot = 0. # ============================================================== # end of the most frequently changed config specified by the user # ============================================================== @@ -44,8 +45,9 @@ torch_compile=False, tensor_float_32=False, model=dict( + # observation_shape=(17, board_size, board_size), observation_shape=(board_size, board_size, 17), - action_space_size=int(1 * board_size * board_size + 1), + action_space_size=int(board_size * board_size + 1), num_res_blocks=1, num_channels=32, ), diff --git a/zoo/board_games/go/config/go_muzero_bot_mode_config.py b/zoo/board_games/go/config/go_muzero_bot_mode_config.py new file mode 100644 index 000000000..ac9c099ed --- /dev/null +++ b/zoo/board_games/go/config/go_muzero_bot_mode_config.py @@ -0,0 +1,100 @@ +from easydict import EasyDict + +# ============================================================== +# begin of the most frequently changed config specified by the user +# ============================================================== +board_size = 6 +collector_env_num = 32 +n_episode = 32 +evaluator_env_num = 5 +num_simulations = 50 +update_per_collect = 50 +batch_size = 256 +max_env_step = int(1e6) +prob_random_action_in_bot = 1 +reanalyze_ratio = 0 + +# board_size = 6 +# collector_env_num = 1 +# n_episode = 1 +# evaluator_env_num = 1 +# num_simulations = 2 +# update_per_collect = 2 +# batch_size = 2 +# max_env_step = int(5e5) +# prob_random_action_in_bot = 0. +# reanalyze_ratio = 0 +# ============================================================== +# end of the most frequently changed config specified by the user +# ============================================================== + +go_muzero_config = dict( + exp_name= + f'data_mz_ctree/go_b{board_size}_rand{prob_random_action_in_bot}_muzero_ns{num_simulations}_upc{update_per_collect}_rr{reanalyze_ratio}_seed0', + env=dict( + board_size=board_size, + komi=7.5, + battle_mode='self_play_mode', + bot_action_type='v0', + prob_random_action_in_bot=prob_random_action_in_bot, + channel_last=True, + collector_env_num=collector_env_num, + evaluator_env_num=evaluator_env_num, + n_evaluator_episode=evaluator_env_num, + manager=dict(shared_memory=False, ), + ), + policy=dict( + model=dict( + observation_shape=(17, board_size, board_size), + action_space_size=int(1 * board_size * board_size + 1), + image_channel=17, + num_res_blocks=1, + num_channels=32, + ), + cuda=True, + env_type='board_games', + game_segment_length=int(board_size * board_size / 2), # for battle_mode='play_with_bot_mode' + update_per_collect=update_per_collect, + batch_size=batch_size, + optim_type='AdamW', + lr_piecewise_constant_decay=False, + learning_rate=0.003, + grad_clip_value=0.5, + num_simulations=num_simulations, + reanalyze_ratio=reanalyze_ratio, + # NOTE：In board_games, we set large td_steps to make sure the value target is the final outcome. + td_steps=int(board_size * board_size / 2), # for battle_mode='play_with_bot_mode' + # NOTE：In board_games, we set discount_factor=1. + discount_factor=1, + n_episode=n_episode, + eval_freq=int(2e3), + replay_buffer_size=int(1e5), + collector_env_num=collector_env_num, + evaluator_env_num=evaluator_env_num, + ), +) +go_muzero_config = EasyDict(go_muzero_config) +main_config = go_muzero_config + +go_muzero_create_config = dict( + env=dict( + type='go', + import_names=['zoo.board_games.go.envs.go_env'], + ), + env_manager=dict(type='subprocess'), + policy=dict( + type='muzero', + import_names=['lzero.policy.muzero'], + ), + collector=dict( + type='episode_muzero', + import_names=['lzero.worker.muzero_collector'], + ) +) +go_muzero_create_config = EasyDict(go_muzero_create_config) +create_config = go_muzero_create_config + +if __name__ == "__main__": + from lzero.entry import train_muzero + + train_muzero([main_config, create_config], seed=0, max_env_step=max_env_step) diff --git a/zoo/board_games/go/config/go_muzero_eval_config.py b/zoo/board_games/go/config/go_muzero_eval_config.py new file mode 100644 index 000000000..2398726c9 --- /dev/null +++ b/zoo/board_games/go/config/go_muzero_eval_config.py @@ -0,0 +1,43 @@ +from zoo.board_games.go.config.go_muzero_bot_mode_config import main_config, create_config +from lzero.entry import eval_muzero +import numpy as np + +if __name__ == '__main__': + """ + model_path (:obj:`Optional[str]`): The pretrained model path, which should + point to the ckpt file of the pretrained model, and an absolute path is recommended. + In LightZero, the path is usually something like ``exp_name/ckpt/ckpt_best.pth.tar``. + """ + model_path = './ckpt/ckpt_best.pth.tar' + seeds = [0] + num_episodes_each_seed = 5 + # If True, you can play with the agent. + main_config.env.agent_vs_human = False + create_config.env_manager.type = 'base' + main_config.env.evaluator_env_num = 1 + main_config.env.n_evaluator_episode = 1 + total_test_episodes = num_episodes_each_seed * len(seeds) + returns_mean_seeds = [] + returns_seeds = [] + for seed in seeds: + returns_mean, returns = eval_muzero( + [main_config, create_config], + seed=seed, + num_episodes_each_seed=num_episodes_each_seed, + print_seed_details=True, + model_path=model_path + ) + returns_mean_seeds.append(returns_mean) + returns_seeds.append(returns) + + returns_mean_seeds = np.array(returns_mean_seeds) + returns_seeds = np.array(returns_seeds) + + print("=" * 20) + print(f'We eval total {len(seeds)} seeds. In each seed, we eval {num_episodes_each_seed} episodes.') + print(f'In seeds {seeds}, returns_mean_seeds is {returns_mean_seeds}, returns is {returns_seeds}') + print('In all seeds, reward_mean:', returns_mean_seeds.mean(), end='. ') + print( + f'win rate: {len(np.where(returns_seeds == 1.)[0]) / total_test_episodes}, draw rate: {len(np.where(returns_seeds == 0.)[0]) / total_test_episodes}, lose rate: {len(np.where(returns_seeds == -1.)[0]) / total_test_episodes}' + ) + print("=" * 20) diff --git a/zoo/board_games/go/config/go_muzero_sp_mode_config.py b/zoo/board_games/go/config/go_muzero_sp_mode_config.py new file mode 100644 index 000000000..a6c783c7d --- /dev/null +++ b/zoo/board_games/go/config/go_muzero_sp_mode_config.py @@ -0,0 +1,102 @@ +from easydict import EasyDict + +# ============================================================== +# begin of the most frequently changed config specified by the user +# ============================================================== +# board_size = 6 +# collector_env_num = 32 +# n_episode = 32 +# evaluator_env_num = 5 +# num_simulations = 50 +# update_per_collect = 50 +# batch_size = 256 +# max_env_step = int(1e6) +# prob_random_action_in_bot = 1 +# reanalyze_ratio = 0 + +board_size = 6 +collector_env_num = 1 +n_episode = 1 +evaluator_env_num = 1 +num_simulations = 2 +update_per_collect = 2 +batch_size = 2 +max_env_step = int(5e5) +prob_random_action_in_bot = 0. +reanalyze_ratio = 0 + +# ============================================================== +# end of the most frequently changed config specified by the user +# ============================================================== + +go_muzero_config = dict( + exp_name= + f'data_mz_ctree/go_muzero_sp-mode_rand{prob_random_action_in_bot}_ns{num_simulations}_upc{update_per_collect}_rr{reanalyze_ratio}_seed0', + env=dict( + board_size=board_size, + komi=7.5, + battle_mode='self_play_mode', + bot_action_type='v0', + prob_random_action_in_bot=prob_random_action_in_bot, + channel_last=True, + collector_env_num=collector_env_num, + evaluator_env_num=evaluator_env_num, + n_evaluator_episode=evaluator_env_num, + manager=dict(shared_memory=False, ), + ), + policy=dict( + model=dict( + observation_shape=(17, board_size, board_size), + action_space_size=int(1 * board_size * board_size + 1), + image_channel=17, + num_res_blocks=1, + num_channels=32, + ), + cuda=True, + env_type='board_games', + # game_segment_length=int(board_size * board_size), # for battle_mode='self_play_mode' + game_segment_length=100, # for battle_mode='self_play_mode' + update_per_collect=update_per_collect, + batch_size=batch_size, + optim_type='AdamW', + lr_piecewise_constant_decay=False, + learning_rate=0.003, + grad_clip_value=0.5, + num_simulations=num_simulations, + reanalyze_ratio=reanalyze_ratio, + # NOTE：In board_games, we set large td_steps to make sure the value target is the final outcome. + td_steps=int(board_size * board_size), # for battle_mode='self_play_mode' + # NOTE：In board_games, we set discount_factor=1. + discount_factor=1, + n_episode=n_episode, + eval_freq=int(2e3), + replay_buffer_size=int(1e5), + collector_env_num=collector_env_num, + evaluator_env_num=evaluator_env_num, + ), +) +go_muzero_config = EasyDict(go_muzero_config) +main_config = go_muzero_config + +go_muzero_create_config = dict( + env=dict( + type='go', + import_names=['zoo.board_games.go.envs.go_env'], + ), + env_manager=dict(type='subprocess'), + policy=dict( + type='muzero', + import_names=['lzero.policy.muzero'], + ), + collector=dict( + type='episode_muzero', + get_train_sample=True, + import_names=['lzero.worker.muzero_collector'], + ) +) +go_muzero_create_config = EasyDict(go_muzero_create_config) +create_config = go_muzero_create_config + +if __name__ == "__main__": + from lzero.entry import train_muzero + train_muzero([main_config, create_config], seed=0, max_env_step=max_env_step) diff --git a/zoo/board_games/go/envs/go_env.py b/zoo/board_games/go/envs/go_env.py index 34f0a521c..e49df2060 100644 --- a/zoo/board_games/go/envs/go_env.py +++ b/zoo/board_games/go/envs/go_env.py @@ -254,10 +254,6 @@ def _player_step(self, action): self._cumulative_rewards[agent] += reward agent = self.agent_selection - # self.dones[agent] = ( - # self._raw_env.terminations[agent_id] - # or self._raw_env.truncations[agent_id] - # ) self.dones[agent] = ( self._raw_env.terminations[agent] or self._raw_env.truncations[agent] From e10e849a8438a471737d14f4ffd99efb42c4b4b6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Sun, 25 Jun 2023 18:19:26 +0800 Subject: [PATCH 15/34] poliah(pu): polish go alphazero/muzero configs --- .../go/config/go_alphazero_bot_mode_config.py | 33 ++- .../go/config/go_alphazero_eval_config.py | 12 +- .../go/config/go_alphazero_sp_mode_config.py | 51 ++-- .../go/config/go_muzero_bot_mode_config.py | 24 +- .../go/config/go_muzero_sp_mode_config.py | 55 +++-- zoo/board_games/go/envs/go_env.py | 105 ++++++++- zoo/board_games/go/envs/test_go_mcts_bot.py | 222 ++++++++++++++++++ zoo/board_games/mcts_bot.py | 39 ++- 8 files changed, 459 insertions(+), 82 deletions(-) create mode 100644 zoo/board_games/go/envs/test_go_mcts_bot.py diff --git a/zoo/board_games/go/config/go_alphazero_bot_mode_config.py b/zoo/board_games/go/config/go_alphazero_bot_mode_config.py index 003e00403..9fc8e0f50 100644 --- a/zoo/board_games/go/config/go_alphazero_bot_mode_config.py +++ b/zoo/board_games/go/config/go_alphazero_bot_mode_config.py @@ -3,15 +3,31 @@ # ============================================================== # begin of the most frequently changed config specified by the user # ============================================================== -board_size = 6 # default_size is 15 -collector_env_num = 32 -n_episode = 32 +board_size = 6 +collector_env_num = 8 +n_episode = 8 evaluator_env_num = 5 -num_simulations = 50 update_per_collect = 50 batch_size = 256 -max_env_step = int(5e5) -prob_random_action_in_bot = 0.5 +max_env_step = int(10e6) +prob_random_action_in_bot = 1 + +if board_size == 19: + num_simulations = 800 +elif board_size == 9: + num_simulations = 180 +elif board_size == 6: + num_simulations = 80 + +# board_size = 6 +# collector_env_num = 1 +# n_episode = 1 +# evaluator_env_num = 1 +# num_simulations = 2 +# update_per_collect = 2 +# batch_size = 2 +# max_env_step = int(5e5) +# prob_random_action_in_bot = 0. # ============================================================== # end of the most frequently changed config specified by the user # ============================================================== @@ -36,7 +52,7 @@ observation_shape=(board_size, board_size, 17), action_space_size=int(1 * board_size * board_size + 1), num_res_blocks=1, - num_channels=32, + num_channels=64, ), cuda=True, board_size=board_size, @@ -45,11 +61,12 @@ optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, - grad_clip_value=0.5, + grad_clip_value=10, value_weight=1.0, entropy_weight=0.0, n_episode=n_episode, eval_freq=int(2e3), + replay_buffer_size=int(1e6), mcts=dict(num_simulations=num_simulations), collector_env_num=collector_env_num, evaluator_env_num=evaluator_env_num, diff --git a/zoo/board_games/go/config/go_alphazero_eval_config.py b/zoo/board_games/go/config/go_alphazero_eval_config.py index 9cbd67392..486c82394 100644 --- a/zoo/board_games/go/config/go_alphazero_eval_config.py +++ b/zoo/board_games/go/config/go_alphazero_eval_config.py @@ -1,4 +1,6 @@ -from zoo.board_games.gomoku.config.gomoku_alphazero_bot_mode_config import main_config, create_config +# from zoo.board_games.go.config.go_alphazero_bot_mode_config import main_config, create_config +from zoo.board_games.go.config.go_alphazero_sp_mode_config import main_config, create_config + from lzero.entry import eval_alphazero import numpy as np @@ -8,11 +10,15 @@ point to the ckpt file of the pretrained model, and an absolute path is recommended. In LightZero, the path is usually something like ``exp_name/ckpt/ckpt_best.pth.tar``. """ - model_path = './ckpt/ckpt_best.pth.tar' + # model_path = './ckpt/ckpt_best.pth.tar' + model_path = '/Users/puyuan/code/LightZero/tb_go_b9_sp/ckpt_best.pth.tar' + seeds = [0] num_episodes_each_seed = 5 # If True, you can play with the agent. - main_config.env.agent_vs_human = False + # main_config.env.agent_vs_human = False + main_config.env.agent_vs_human = True + create_config.env_manager.type = 'base' main_config.env.evaluator_env_num = 1 main_config.env.n_evaluator_episode = 1 diff --git a/zoo/board_games/go/config/go_alphazero_sp_mode_config.py b/zoo/board_games/go/config/go_alphazero_sp_mode_config.py index 6a61730a2..23598b4ca 100644 --- a/zoo/board_games/go/config/go_alphazero_sp_mode_config.py +++ b/zoo/board_games/go/config/go_alphazero_sp_mode_config.py @@ -4,31 +4,37 @@ # ============================================================== # begin of the most frequently changed config specified by the user # ============================================================== -# board_size = 6 -# collector_env_num = 32 -# n_episode = 32 -# evaluator_env_num = 5 -# num_simulations = 50 -# update_per_collect = 50 -# batch_size = 256 -# max_env_step = int(1e6) -# prob_random_action_in_bot = 1 - board_size = 6 -collector_env_num = 1 -n_episode = 1 -evaluator_env_num = 1 -num_simulations = 2 -update_per_collect = 2 -batch_size = 2 -max_env_step = int(5e5) -prob_random_action_in_bot = 0. +collector_env_num = 8 +n_episode = 8 +evaluator_env_num = 5 +update_per_collect = 50 +batch_size = 256 +max_env_step = int(10e6) +prob_random_action_in_bot = 1 + +if board_size == 19: + num_simulations = 800 +elif board_size == 9: + num_simulations = 180 +elif board_size == 6: + num_simulations = 80 + +# board_size = 6 +# collector_env_num = 1 +# n_episode = 1 +# evaluator_env_num = 1 +# num_simulations = 2 +# update_per_collect = 2 +# batch_size = 2 +# max_env_step = int(5e5) +# prob_random_action_in_bot = 0. # ============================================================== # end of the most frequently changed config specified by the user # ============================================================== go_alphazero_config = dict( exp_name= - f'data_az_ptree/go_alphazero_sp-mode_rand{prob_random_action_in_bot}_ns{num_simulations}_upc{update_per_collect}_seed0', + f'data_az_ptree/go_b{board_size}_alphazero_sp-mode_rand{prob_random_action_in_bot}_ns{num_simulations}_upc{update_per_collect}_seed0', env=dict( board_size=board_size, komi=7.5, @@ -42,14 +48,14 @@ manager=dict(shared_memory=False, ), ), policy=dict( + env_type='board_games', torch_compile=False, tensor_float_32=False, model=dict( - # observation_shape=(17, board_size, board_size), observation_shape=(board_size, board_size, 17), action_space_size=int(board_size * board_size + 1), num_res_blocks=1, - num_channels=32, + num_channels=64, ), cuda=True, board_size=board_size, @@ -59,11 +65,12 @@ lr_piecewise_constant_decay=False, learning_rate=0.003, manual_temperature_decay=True, - grad_clip_value=0.5, + grad_clip_value=10, value_weight=1.0, entropy_weight=0.0, n_episode=n_episode, eval_freq=int(2e3), + replay_buffer_size=int(1e6), mcts=dict(num_simulations=num_simulations), collector_env_num=collector_env_num, evaluator_env_num=evaluator_env_num, diff --git a/zoo/board_games/go/config/go_muzero_bot_mode_config.py b/zoo/board_games/go/config/go_muzero_bot_mode_config.py index ac9c099ed..27e62687f 100644 --- a/zoo/board_games/go/config/go_muzero_bot_mode_config.py +++ b/zoo/board_games/go/config/go_muzero_bot_mode_config.py @@ -4,16 +4,22 @@ # begin of the most frequently changed config specified by the user # ============================================================== board_size = 6 -collector_env_num = 32 -n_episode = 32 +collector_env_num = 8 +n_episode = 8 evaluator_env_num = 5 -num_simulations = 50 update_per_collect = 50 batch_size = 256 max_env_step = int(1e6) prob_random_action_in_bot = 1 reanalyze_ratio = 0 +if board_size == 19: + num_simulations = 800 +elif board_size == 9: + num_simulations = 180 +elif board_size == 6: + num_simulations = 80 + # board_size = 6 # collector_env_num = 1 # n_episode = 1 @@ -49,26 +55,28 @@ action_space_size=int(1 * board_size * board_size + 1), image_channel=17, num_res_blocks=1, - num_channels=32, + num_channels=64, ), cuda=True, env_type='board_games', - game_segment_length=int(board_size * board_size / 2), # for battle_mode='play_with_bot_mode' + # game_segment_length=int(board_size * board_size / 2), # for battle_mode='play_with_bot_mode' + game_segment_length=100, update_per_collect=update_per_collect, batch_size=batch_size, optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, - grad_clip_value=0.5, + grad_clip_value=10, num_simulations=num_simulations, reanalyze_ratio=reanalyze_ratio, # NOTE：In board_games, we set large td_steps to make sure the value target is the final outcome. - td_steps=int(board_size * board_size / 2), # for battle_mode='play_with_bot_mode' + # td_steps=int(board_size * board_size / 2), # for battle_mode='play_with_bot_mode' + td_steps=100, # NOTE：In board_games, we set discount_factor=1. discount_factor=1, n_episode=n_episode, eval_freq=int(2e3), - replay_buffer_size=int(1e5), + replay_buffer_size=int(1e6), collector_env_num=collector_env_num, evaluator_env_num=evaluator_env_num, ), diff --git a/zoo/board_games/go/config/go_muzero_sp_mode_config.py b/zoo/board_games/go/config/go_muzero_sp_mode_config.py index a6c783c7d..b3ba47937 100644 --- a/zoo/board_games/go/config/go_muzero_sp_mode_config.py +++ b/zoo/board_games/go/config/go_muzero_sp_mode_config.py @@ -3,28 +3,34 @@ # ============================================================== # begin of the most frequently changed config specified by the user # ============================================================== -# board_size = 6 -# collector_env_num = 32 -# n_episode = 32 -# evaluator_env_num = 5 -# num_simulations = 50 -# update_per_collect = 50 -# batch_size = 256 -# max_env_step = int(1e6) -# prob_random_action_in_bot = 1 -# reanalyze_ratio = 0 - board_size = 6 -collector_env_num = 1 -n_episode = 1 -evaluator_env_num = 1 -num_simulations = 2 -update_per_collect = 2 -batch_size = 2 -max_env_step = int(5e5) -prob_random_action_in_bot = 0. +collector_env_num = 8 +n_episode = 8 +evaluator_env_num = 5 +update_per_collect = 50 +batch_size = 256 +max_env_step = int(1e6) +prob_random_action_in_bot = 1 reanalyze_ratio = 0 +if board_size == 19: + num_simulations = 800 +elif board_size == 9: + num_simulations = 180 +elif board_size == 6: + num_simulations = 80 + +# board_size = 6 +# collector_env_num = 1 +# n_episode = 1 +# evaluator_env_num = 1 +# num_simulations = 2 +# update_per_collect = 2 +# batch_size = 2 +# max_env_step = int(5e5) +# prob_random_action_in_bot = 0. +# reanalyze_ratio = 0 + # ============================================================== # end of the most frequently changed config specified by the user # ============================================================== @@ -50,27 +56,28 @@ action_space_size=int(1 * board_size * board_size + 1), image_channel=17, num_res_blocks=1, - num_channels=32, + num_channels=64, ), cuda=True, env_type='board_games', # game_segment_length=int(board_size * board_size), # for battle_mode='self_play_mode' - game_segment_length=100, # for battle_mode='self_play_mode' + game_segment_length=100, update_per_collect=update_per_collect, batch_size=batch_size, optim_type='AdamW', lr_piecewise_constant_decay=False, learning_rate=0.003, - grad_clip_value=0.5, + grad_clip_value=10, num_simulations=num_simulations, reanalyze_ratio=reanalyze_ratio, # NOTE：In board_games, we set large td_steps to make sure the value target is the final outcome. - td_steps=int(board_size * board_size), # for battle_mode='self_play_mode' + # td_steps=int(board_size * board_size), # for battle_mode='self_play_mode' + td_steps=100, # NOTE：In board_games, we set discount_factor=1. discount_factor=1, n_episode=n_episode, eval_freq=int(2e3), - replay_buffer_size=int(1e5), + replay_buffer_size=int(1e6), collector_env_num=collector_env_num, evaluator_env_num=evaluator_env_num, ), diff --git a/zoo/board_games/go/envs/go_env.py b/zoo/board_games/go/envs/go_env.py index e49df2060..0cfc8889f 100644 --- a/zoo/board_games/go/envs/go_env.py +++ b/zoo/board_games/go/envs/go_env.py @@ -1,4 +1,6 @@ import copy + +from ding.torch_utils import to_list from ditk import logging import os @@ -77,6 +79,10 @@ def current_player_index(self): @property def to_play(self): + """ + current_player_index = 0, current_player = 1, to_play = 2 + current_player_index = 1, current_player = 2, to_play = 1 + """ return self.players[0] if self.current_player == self.players[1] else self.players[1] @property @@ -156,6 +162,7 @@ def reset(self, start_player_index=0, init_state=None): if init_state is not None: # Represent a board as a numpy array, with 0 empty, 1 is black, -1 is white. + # Note, to_play in Position is different from to_play in GoEnv. self._raw_env._go = go_base.Position(board=copy.deepcopy(init_state), komi=self._komi, to_play=1 if self.start_player_index == 0 else -1) else: @@ -357,6 +364,29 @@ def get_done_winner(self): else: return False, -1 + + def get_done_reward(self): + """ + Overview: + Check if the game is over and what is the reward in the perspective of player 1. + Return 'done' and 'reward'. + Returns: + - outputs (:obj:`Tuple`): Tuple containing 'done' and 'reward', + - if player 1 win, 'done' = True, 'reward' = 1 + - if player 2 win, 'done' = True, 'reward' = -1 + - if draw, 'done' = True, 'reward' = 0 + - if game is not over, 'done' = False,'reward' = None + """ + if self._raw_env._go.is_game_over(): + result = self._raw_env._go.result() + if result == 1: + return True, 1 + elif result == -1: + return True, -1 + elif result == 0: + return True, 0 + else: + return False, None def observe(self, agent): current_agent_plane, opponent_agent_plane = self._raw_env._encode_board_planes(agent) player_plane = self._raw_env._encode_player_plane(agent) @@ -403,8 +433,11 @@ def current_state(self): @property def legal_actions(self): - return self.legal_moves() + return to_list(self.legal_moves()) + @property + def board(self): + return self._raw_env._go.board def legal_moves(self): if self._raw_env._go.is_game_over(): self.terminations = self._convert_to_dict( @@ -419,6 +452,57 @@ def legal_moves(self): return self.next_legal_moves + def coord_to_action(self, i, j): + """ + Overview: + convert coordinate i, j to action index a in [0, board_size**2) + """ + return i * self.board_size + j + + def action_to_coord(self, a): + """ + Overview: + convert action index a in [0, board_size**2) to coordinate (i, j) + """ + return a // self.board_size, a % self.board_size + + def action_to_string(self, action_number): + """ + Overview: + Convert an action number to a string representing the action. + Arguments: + - action_number: an integer from the action space. + Returns: + - String representing the action. + """ + row = action_number // self.board_size + 1 + col = action_number % self.board_size + 1 + return f"Play row {row}, column {col}" + + def simulate_action(self, action): + """ + Overview: + execute action and get next_simulator_env. used in AlphaZero. + Returns: + Returns Gomoku instance. + """ + if action not in self.legal_actions: + raise ValueError("action {0} on board {1} is not legal".format(action, self.board)) + if self.start_player_index == 0: + start_player_index = 1 # self.players = [1, 2], start_player = 2, start_player_index = 1 + else: + start_player_index = 0 # self.players = [1, 2], start_player = 1, start_player_index = 0 + # next_simulator_env = copy.deepcopy(self) + raw_env = copy.deepcopy(self._raw_env) + # tmp_position = next_simulator_env._raw_env._go.play_move(coords.from_flat(action)) + tmp_position = raw_env._go.play_move(coords.from_flat(action)) + new_board = copy.deepcopy(tmp_position.board) + next_simulator_env = copy.deepcopy(self) + next_simulator_env.reset(start_player_index, init_state=new_board) # index + # NOTE: when call reset, self.recent is cleared + next_simulator_env._raw_env._go.recent = tmp_position.recent + + return next_simulator_env def random_action(self): return np.random.choice(self.legal_actions) @@ -436,11 +520,24 @@ def human_to_action(self): # print(self.board) while True: try: - print(f"Current available actions for the player {self.to_play()} are:{self.legal_moves()}") - choice = int(input(f"Enter the index of next move for the player {self.to_play()}: ")) - if choice in self.legal_moves(): + row = int( + input( + f"Enter the row (1, 2, ...,{self.board_size}, from up to bottom) to play for the player {self.current_player}: " + ) + ) + col = int( + input( + f"Enter the column (1, 2, ...,{self.board_size}, from left to right) to play for the player {self.current_player}: " + ) + ) + choice = self.coord_to_action(row - 1, col - 1) + if (choice in self.legal_actions and 1 <= row and 1 <= col and row <= self.board_size + and col <= self.board_size): break + else: + print("Wrong input, try again") except KeyboardInterrupt: + print("exit") sys.exit(0) except Exception as e: print("Wrong input, try again") diff --git a/zoo/board_games/go/envs/test_go_mcts_bot.py b/zoo/board_games/go/envs/test_go_mcts_bot.py new file mode 100644 index 000000000..98f5bb394 --- /dev/null +++ b/zoo/board_games/go/envs/test_go_mcts_bot.py @@ -0,0 +1,222 @@ +from easydict import EasyDict +from zoo.board_games.go.envs.go_env import GoEnv +from zoo.board_games.mcts_bot import MCTSBot + +import pytest + +cfg = EasyDict(dict( + # board_size=6, + # num_simulations=50, + num_simulations=50, + board_size=5, + komi=7.5, + prob_random_agent=0, + prob_expert_agent=0, + battle_mode='self_play_mode', + scale=True, + channel_last=True, + agent_vs_human=False, + bot_action_type='alpha_beta_pruning', # {'v0', 'alpha_beta_pruning'} + prob_random_action_in_bot=0., + check_action_to_connect4_in_bot_v0=False, +)) + + +@pytest.mark.envtest +class TestGoBot: + + def test_go_mcts_vs_random(self): + # player_0 num_simulation=1000, will win + # player_1 num_simulation=1 + env = GoEnv(cfg) + env.reset() + state = env._raw_env._go.board + player_0 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 + + player_index = 0 # player 1 first + print('#' * 15) + print(state) + print('#' * 15) + print('\n') + while not env.get_done_reward()[0]: + if player_index == 0: + action = player_0.get_actions(state, player_index=player_index) + player_index = 1 + else: + print('-' * 40) + # action = player_1.get_actions(state, player_index=player_index) + action = env.random_action() + player_index = 0 + # print('-' * 40) + env.step(action) + state = env._raw_env._go.board + print('-' * 40) + print(state) + # print('#' * 15) + assert env.get_done_winner()[1] == 1, f'winner is {env.get_done_winner()[1]}, player 1 should win' + + def test_go_self_play_mode_player0_win(self): + # player_0 num_simulation=1000, will win + # player_1 num_simulation=1 + env = GoEnv(cfg) + env.reset() + state = env._raw_env._go.board + player_0 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 + player_1 = MCTSBot(GoEnv, cfg, 'player 2', int(cfg.num_simulations/2)) # player_index = 1, player = 2 + + player_index = 0 # player 1 first + print('#' * 15) + print(state) + print('#' * 15) + print('\n') + while not env.get_done_reward()[0]: + if player_index == 0: + action = player_0.get_actions(state, player_index=player_index) + player_index = 1 + else: + print('-' * 40) + action = player_1.get_actions(state, player_index=player_index) + player_index = 0 + # print('-' * 40) + env.step(action) + state = env._raw_env._go.board + print('-' * 40) + print(state) + # print('#' * 15) + assert env.get_done_winner()[1] == 1, f'winner is {env.get_done_winner()[1]}, player 1 should win' + + def test_go_self_play_mode_player1_win(self): + # player_0 num_simulation=1 + # player_1 num_simulation=1000, will win + env = GoEnv(cfg) + env.reset() + state = env._raw_env._go.board + player_0 = MCTSBot(GoEnv, cfg, 'player 1', 1) # player_index = 0, player = 1 + player_1 = MCTSBot(GoEnv, cfg, 'player 2', cfg.num_simulations) # player_index = 1, player = 2 + + player_index = 0 # player 1 first + print('#' * 15) + print(state) + print('#' * 15) + print('\n') + while not env.get_done_reward()[0]: + if player_index == 0: + action = player_0.get_actions(state, player_index=player_index) + player_index = 1 + else: + print('-' * 40) + action = player_1.get_actions(state, player_index=player_index) + player_index = 0 + env.step(action) + state = env._raw_env._go.board + print('-' * 40) + print(state) + assert env.get_done_winner()[1] == 2, f'winner is {env.get_done_winner()[1]}, player 2 should win' + + + def test_go_self_play_mode_draw(self): + # player_0 num_simulation=1000 + # player_1 num_simulation=1000, will draw + env = GoEnv(cfg) + env.reset() + state = env._raw_env._go.board + player_0 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 + player_1 = MCTSBot(GoEnv, cfg, 'player 2', cfg.num_simulations) # player_index = 1, player = 2 + + player_index = 0 # player 1 fist + print('#' * 15) + print(state) + print('#' * 15) + print('\n') + while not env.get_done_reward()[0]: + if player_index == 0: + action = player_0.get_actions(state, player_index=player_index) + player_index = 1 + else: + print('-' * 40) + action = player_1.get_actions(state, player_index=player_index) + player_index = 0 + env.step(action) + state = env._raw_env._go.board + print('-' * 40) + print(state) + assert env.get_done_winner()[1] == -1, f'winner is {env.get_done_winner()[1]}, two players should draw' + + # def test_go_self_play_mode_case_1(self): + # env = GoEnv(cfg) + # init_state = [ + # [1, 1, 1, 1, 0], + # [1, 0, 0, 0, 2], + # [0, 0, 2, 0, 2], + # [0, 2, 0, 0, 2], + # [2, 1, 1, 0, 0], + # ] + # player_0 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 + # player_1 = MCTSBot(GoEnv, cfg, 'player 2', cfg.num_simulations) # player_index = 1, player = 2 + # player_index = 1 # player 1 fist + # + # env.reset(player_index, init_state) + # state = env._raw_env._go.board + # + # print('#' * 15) + # print(state) + # print('#' * 15) + # print('\n') + # while not env.get_done_reward()[0]: + # if player_index == 0: + # action = player_0.get_actions(state, player_index=player_index) + # player_index = 1 + # else: + # print('-' * 40) + # action = player_1.get_actions(state, player_index=player_index) + # player_index = 0 + # print('-' * 40) + # env.step(action) + # state = env._raw_env._go.board + # print('#' * 15) + # print(state) + # print('#' * 15) + # row, col = env.action_to_coord(action) + # assert env.get_done_winner()[1] == 2 + # assert state[0, 4] == 2 + # + # def test_go_self_play_mode_case_2(self): + # env = GoEnv(cfg) + # init_state = [ + # [0, 0, 2, 0, 0], + # [0, 1, 2, 0, 0], + # [2, 2, 1, 0, 0], + # [2, 0, 0, 1, 2], + # [1, 1, 1, 0, 0], + # ] + # player_0 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 + # player_1 = MCTSBot(GoEnv, cfg, 'player 2', cfg.num_simulations) # player_index = 1, player = 2 + # player_index = 0 # player 1 fist + # + # env.reset(player_index, init_state) + # state = env._raw_env._go.board + # + # print('#' * 15) + # print(state) + # print('#' * 15) + # print('\n') + # while not env.get_done_reward()[0]: + # if player_index == 0: + # action = player_0.get_actions(state, player_index=player_index) + # player_index = 1 + # else: + # print('-' * 40) + # action = player_1.get_actions(state, player_index=player_index) + # player_index = 0 + # print('-' * 40) + # env.step(action) + # state = env._raw_env._go.board + # print('#' * 15) + # print(state) + # print('#' * 15) + # row, col = env.action_to_coord(action) + # assert env.get_done_winner()[1] == 1 + # assert state[4, 4] == 1 + + +test = TestGoBot().test_go_self_play_mode_player0_win() \ No newline at end of file diff --git a/zoo/board_games/mcts_bot.py b/zoo/board_games/mcts_bot.py index 518653a0c..e9a7eace2 100644 --- a/zoo/board_games/mcts_bot.py +++ b/zoo/board_games/mcts_bot.py @@ -64,22 +64,25 @@ def is_fully_expanded(self): return len(self.legal_actions) == 0 def best_child(self, c_param=1.4): - ''' + """ Overview: - computer ucb score. ucb = (q / n) + c_param * np.sqrt((2 * np.log(visited_num) / n)) - - q: The estimated value of Node. + - q: The estimated value of Node. - n: The simulation num of Node. - visited_num: The visited num of Node - c_param: constant num=1.4. - Select the node with the highest ucb score. - ''' + """ choices_weights = [(c.q / c.n) + c_param * np.sqrt((2 * np.log(self.n) / c.n)) for c in self.children] self.best_action = self.parent_action[np.argmax(choices_weights)] return self.children[np.argmax(choices_weights)] - def rollout_policy(self, possible_actions): - return possible_actions[np.random.randint(len(possible_actions))] + def rollout_policy(self, legal_actions, last_legal_actions=None, last_action=None): + if last_legal_actions is not None and last_legal_actions == [self.env.board_size ** 2] and last_action is not None and last_action == self.env.board_size ** 2: + # for Go env, if last_action is not None, and last_action == self.env.board_size ** 2, then pass + return legal_actions[-1] + return legal_actions[np.random.randint(len(legal_actions))] class TwoPlayersMCTSNode(MCTSNode): @@ -98,16 +101,16 @@ def legal_actions(self): @property def q(self): - ''' + """ Overview: - The estimated value of Node. + The estimated value of Node. self._results[1] means current_player 1 number of wins. self._results[-1] means current_player 2 number of wins. Example: result[1] = 10, result[-1] = 5, As current_player_1, q = 10 - 5 = 5 As current_player_2, q = 5 - 10 = -5 - ''' + """ # print(self._results) # print('parent.current_player={}'.format(self.parent.env.current_player)) if self.parent.env.current_player == 1: @@ -139,13 +142,23 @@ def rollout(self): # print('simulation begin') current_rollout_env = self.env # print(current_rollout_env.board) + step=0 + last_action=None + last_legal_actions=None while not current_rollout_env.get_done_reward()[0]: - possible_actions = current_rollout_env.legal_actions - action = self.rollout_policy(possible_actions) - current_rollout_env = current_rollout_env.simulate_action(action) - # print('\n') + step += 1 + + + legal_actions = current_rollout_env.legal_actions + action = self.rollout_policy(legal_actions, last_legal_actions, last_action) + # print('step={}'.format(step)) # print(current_rollout_env.board) - # print('simulation end \n') + # print('legal_actions={}'.format(legal_actions)) + # print('action={}'.format(action)) + current_rollout_env = current_rollout_env.simulate_action(action) + last_action = action + last_legal_actions = legal_actions + # print('simulation end') return current_rollout_env.get_done_reward()[1] def backpropagate(self, result): From b0509d46582455fcbfe175aaade82d2e9f15963c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Wed, 28 Jun 2023 21:59:40 +0800 Subject: [PATCH 16/34] feature(pu): add eval_go_mcts_bot_speed_win-rate.py, polish test_go_mcts_bot.py --- .../go/config/go_alphazero_sp_mode_config.py | 50 +-- .../go/config/go_muzero_bot_mode_config.py | 2 +- .../go/config/go_muzero_sp_mode_config.py | 2 +- .../envs/eval_go_mcts_bot_speed_win-rate.py | 185 ++++++++++ zoo/board_games/go/envs/go_env.py | 24 +- zoo/board_games/go/envs/go_env_bkp.py | 330 ------------------ zoo/board_games/go/envs/test_go_env.py | 98 +++--- zoo/board_games/go/envs/test_go_mcts_bot.py | 228 ++++++------ zoo/board_games/mcts_bot.py | 15 +- 9 files changed, 386 insertions(+), 548 deletions(-) create mode 100644 zoo/board_games/go/envs/eval_go_mcts_bot_speed_win-rate.py delete mode 100644 zoo/board_games/go/envs/go_env_bkp.py diff --git a/zoo/board_games/go/config/go_alphazero_sp_mode_config.py b/zoo/board_games/go/config/go_alphazero_sp_mode_config.py index 23598b4ca..774294ca9 100644 --- a/zoo/board_games/go/config/go_alphazero_sp_mode_config.py +++ b/zoo/board_games/go/config/go_alphazero_sp_mode_config.py @@ -4,31 +4,31 @@ # ============================================================== # begin of the most frequently changed config specified by the user # ============================================================== -board_size = 6 -collector_env_num = 8 -n_episode = 8 -evaluator_env_num = 5 -update_per_collect = 50 -batch_size = 256 -max_env_step = int(10e6) -prob_random_action_in_bot = 1 - -if board_size == 19: - num_simulations = 800 -elif board_size == 9: - num_simulations = 180 -elif board_size == 6: - num_simulations = 80 - # board_size = 6 -# collector_env_num = 1 -# n_episode = 1 -# evaluator_env_num = 1 -# num_simulations = 2 -# update_per_collect = 2 -# batch_size = 2 -# max_env_step = int(5e5) -# prob_random_action_in_bot = 0. +# collector_env_num = 8 +# n_episode = 8 +# evaluator_env_num = 5 +# update_per_collect = 50 +# batch_size = 256 +# max_env_step = int(10e6) +# prob_random_action_in_bot = 1 +# +# if board_size == 19: +# num_simulations = 800 +# elif board_size == 9: +# num_simulations = 180 +# elif board_size == 6: +# num_simulations = 80 + +board_size = 6 +collector_env_num = 1 +n_episode = 1 +evaluator_env_num = 1 +num_simulations = 2 +update_per_collect = 2 +batch_size = 2 +max_env_step = int(5e5) +prob_random_action_in_bot = 0. # ============================================================== # end of the most frequently changed config specified by the user # ============================================================== @@ -82,7 +82,7 @@ go_alphazero_create_config = dict( env=dict( - type='go', + type='go_lightzero', import_names=['zoo.board_games.go.envs.go_env'], ), env_manager=dict(type='subprocess'), diff --git a/zoo/board_games/go/config/go_muzero_bot_mode_config.py b/zoo/board_games/go/config/go_muzero_bot_mode_config.py index 27e62687f..c5edb5a94 100644 --- a/zoo/board_games/go/config/go_muzero_bot_mode_config.py +++ b/zoo/board_games/go/config/go_muzero_bot_mode_config.py @@ -86,7 +86,7 @@ go_muzero_create_config = dict( env=dict( - type='go', + type='go_lightzero', import_names=['zoo.board_games.go.envs.go_env'], ), env_manager=dict(type='subprocess'), diff --git a/zoo/board_games/go/config/go_muzero_sp_mode_config.py b/zoo/board_games/go/config/go_muzero_sp_mode_config.py index b3ba47937..7c3e249f8 100644 --- a/zoo/board_games/go/config/go_muzero_sp_mode_config.py +++ b/zoo/board_games/go/config/go_muzero_sp_mode_config.py @@ -87,7 +87,7 @@ go_muzero_create_config = dict( env=dict( - type='go', + type='go_lightzero', import_names=['zoo.board_games.go.envs.go_env'], ), env_manager=dict(type='subprocess'), diff --git a/zoo/board_games/go/envs/eval_go_mcts_bot_speed_win-rate.py b/zoo/board_games/go/envs/eval_go_mcts_bot_speed_win-rate.py new file mode 100644 index 000000000..702e6439f --- /dev/null +++ b/zoo/board_games/go/envs/eval_go_mcts_bot_speed_win-rate.py @@ -0,0 +1,185 @@ +from easydict import EasyDict +from zoo.board_games.go.envs.go_env import GoEnv +from zoo.board_games.mcts_bot import MCTSBot + +import pytest +import time +import numpy as np + + +def test_go_mcts_vs_random(num_simulations): + mcts_bot_time_list = [] + random_bot_time_list = [] + winner = [] + for i in range(10): + print('-' * 10 + 'episode' + str(i) + '-' * 10) + + # player_0 num_simulation=1000, will win + # player_1 num_simulation=1 + env = GoEnv(cfg) + obs = env.reset() + state = obs['board'] + player_1 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 + + player_index = 0 # player 1 first + # print('#' * 15) + # print(state) + # print('#' * 15) + while not env.get_done_reward()[0]: + if player_index == 0: + t1 = time.time() + action = player_1.get_actions(state, player_index=player_index) + t2 = time.time() + mcts_bot_time_list.append(t2 - t1) + + player_index = 1 + else: + # print('-' * 40) + t1 = time.time() + action = env.random_action() + t2 = time.time() + random_bot_time_list.append(t2 - t1) + player_index = 0 + + timestep = env.step(action) + # env.render('human') + # time.sleep(0.1) + state = timestep.obs['board'] + # print('-' * 40) + # print(state) + winner.append(env.get_done_winner()[1]) + + mcts_bot_mu = np.mean(mcts_bot_time_list) + mcts_bot_std = np.std(mcts_bot_time_list) + + random_bot_mu = np.mean(random_bot_time_list) + random_bot_std = np.std(random_bot_time_list) + + print('num_simulations={}\n'.format(num_simulations)) + + print('mcts_bot_time_list={}\n'.format(mcts_bot_time_list)) + print('mcts_bot_mu={}, bot_action_std={}\n'.format(mcts_bot_mu, mcts_bot_std)) + + print('random_bot_time_list={}\n'.format(random_bot_time_list)) + print('random_bot_mu={}, random_bot_std={}\n'.format(random_bot_mu, random_bot_std)) + + print( + 'winner={}, draw={}, player1={}, player2={}\n'.format( + winner, winner.count(-1), winner.count(1), winner.count(2) + ) + ) + + +def test_go_mcts_vs_mcts(num_simulations_player_1, num_simulations_player_2): + mcts_bot_1_time_list = [] + mcts_bot_2_time_list = [] + winner = [] + for i in range(10): + print('-' * 10 + 'episode' + str(i) + '-' * 10) + + # player_0 num_simulation=1000, will win + # player_1 num_simulation=1 + env = GoEnv(cfg) + obs = env.reset() + state = obs['board'] + player_1 = MCTSBot(GoEnv, cfg, 'player 1', num_simulations_player_1) # player_index = 0, player = 1 + player_2 = MCTSBot(GoEnv, cfg, 'player 2', num_simulations_player_2) # player_index = 1, player = 2 + + player_index = 0 # player 1 first + # print('#' * 15) + # print(state) + # print('#' * 15) + while not env.get_done_reward()[0]: + if player_index == 0: + t1 = time.time() + action = player_1.get_actions(state, player_index=player_index) + t2 = time.time() + mcts_bot_1_time_list.append(t2 - t1) + + player_index = 1 + else: + # print('-' * 40) + t1 = time.time() + action = player_2.get_actions(state, player_index=player_index) + t2 = time.time() + mcts_bot_2_time_list.append(t2 - t1) + + player_index = 0 + + timestep = env.step(action) + # env.render('human') + # time.sleep(0.1) + state = timestep.obs['board'] + # print('-' * 40) + # print(state) + winner.append(env.get_done_winner()[1]) + + mcts_bot_1_mu = np.mean(mcts_bot_1_time_list) + mcts_bot_1_std = np.std(mcts_bot_1_time_list) + + mcts_bot_2_mu = np.mean(mcts_bot_2_time_list) + mcts_bot_2_std = np.std(mcts_bot_2_time_list) + + print('num_simulations_player_1 ={}\n'.format(num_simulations_player_1)) + print('num_simulations_player_2 ={}\n'.format(num_simulations_player_2)) + + print('mcts_bot_1_time_list={}\n'.format(mcts_bot_1_time_list)) + print('mcts_bot_1_mu={}, mcts_bot_1_std={}\n'.format(mcts_bot_1_mu, mcts_bot_1_std)) + + print('mcts_bot_2_time_list={}\n'.format(mcts_bot_2_time_list)) + print('mcts_bot_2_mu={}, bot_action_std={}\n'.format(mcts_bot_2_mu, mcts_bot_2_std)) + + print( + 'winner={}, draw={}, player1={}, player2={}\n'.format( + winner, winner.count(-1), winner.count(1), winner.count(2) + ) + ) + + +if __name__ == '__main__': + cfg = EasyDict(dict( + board_size=5, + komi=0.5, + num_simulations=2, + num_simulations_player_1=2, + num_simulations_player_2=2, + + # board_size=6, + # komi=2.5, + # num_simulations=80, + # num_simulations_player_1=80, + # num_simulations_player_2=80, + + # board_size=9, + # komi=4.5, + # num_simulations=180, + # num_simulations_player_1=180, + # num_simulations_player_2=180, + + # board_size=19, + # komi=7.5, + # num_simulations=800, + # num_simulations_player_1=800, + # num_simulations_player_2=800, + + prob_random_agent=0, + prob_expert_agent=0, + battle_mode='self_play_mode', + scale=True, + channel_last=True, + agent_vs_human=False, + bot_action_type='alpha_beta_pruning', # {'v0', 'alpha_beta_pruning'} + prob_random_action_in_bot=0., + check_action_to_connect4_in_bot_v0=False, + )) + + # ============================================================== + # test win rate between mcts_bot and random_bot + # ============================================================== + test_go_mcts_vs_random(num_simulations=cfg.num_simulations) + + # ============================================================== + # test win rate between mcts_bot and mcts_bot + # ============================================================== + test_go_mcts_vs_mcts(num_simulations_player_1=cfg.num_simulations_player_1, + num_simulations_player_2=cfg.num_simulations_player_2) diff --git a/zoo/board_games/go/envs/go_env.py b/zoo/board_games/go/envs/go_env.py index 0cfc8889f..90170b10b 100644 --- a/zoo/board_games/go/envs/go_env.py +++ b/zoo/board_games/go/envs/go_env.py @@ -15,6 +15,8 @@ from easydict import EasyDict from gym import spaces from pettingzoo.classic import go_v5 +from pettingzoo.classic.go.go import raw_env + from pettingzoo.classic.go import coords, go_base from pettingzoo.utils.agent_selector import agent_selector @@ -30,7 +32,7 @@ def get_image(path): return sfc -@ENV_REGISTRY.register('go') +@ENV_REGISTRY.register('go_lightzero') class GoEnv(BaseEnv): """ Overview: @@ -139,7 +141,6 @@ def __init__(self, cfg=None): self.board_history = np.zeros((self.board_size, self.board_size, 16), dtype=bool) - # Represent a board as a numpy array, with 0 empty, 1 is black, -1 is white. def reset(self, start_player_index=0, init_state=None): self.start_player_index = start_player_index @@ -153,12 +154,8 @@ def reset(self, start_player_index=0, init_state=None): self._agent_selector = agent_selector(['white_0', 'black_0']) self.agent_selection = self._agent_selector.next() - - self.has_reset = True - self._go = go_v5.env(board_size=self.board_size, komi=self._komi) - # self._go = raw_env(board_size=self.board_size, komi=self._komi) - self._go.reset() - self._raw_env = self._go.env.env.env + self._raw_env = raw_env(board_size=self.board_size, komi=self._komi) + self._raw_env.reset() if init_state is not None: # Represent a board as a numpy array, with 0 empty, 1 is black, -1 is white. @@ -229,6 +226,7 @@ def _player_step(self, action): self.board_history = np.dstack((current_agent_plane, opponent_agent_plane, self.board_history[:, :, :-2])) # self.board_history[:,:,0], self.board_history[:,:,1] + current_agent = self.agent_selection # next_player: 'black_0', 'white_0' """ NOTE: here exchange the player @@ -268,7 +266,7 @@ def _player_step(self, action): if self.dones[agent]: self.infos[agent]['eval_episode_return'] = self._cumulative_rewards[agent] - return BaseEnvTimestep(obs, self._cumulative_rewards[agent], self.dones[agent], self.infos[agent]) + return BaseEnvTimestep(obs, self.rewards[current_agent], self.dones[agent], self.infos[agent]) def step(self, action): if self.battle_mode == 'self_play_mode': @@ -364,7 +362,6 @@ def get_done_winner(self): else: return False, -1 - def get_done_reward(self): """ Overview: @@ -387,6 +384,7 @@ def get_done_reward(self): return True, 0 else: return False, None + def observe(self, agent): current_agent_plane, opponent_agent_plane = self._raw_env._encode_board_planes(agent) player_plane = self._raw_env._encode_player_plane(agent) @@ -399,6 +397,7 @@ def observe(self, agent): action_mask[i] = 1 return {"observation": observation, "action_mask": action_mask} + def current_state(self): """ Overview: @@ -418,7 +417,6 @@ def current_state(self): # obs = self._raw_env.observe(agent_id) obs = self.observe(agent_id) - obs['observation'] = obs['observation'].astype(int) raw_obs = obs['observation'] @@ -438,6 +436,7 @@ def legal_actions(self): @property def board(self): return self._raw_env._go.board + def legal_moves(self): if self._raw_env._go.is_game_over(): self.terminations = self._convert_to_dict( @@ -499,10 +498,11 @@ def simulate_action(self, action): new_board = copy.deepcopy(tmp_position.board) next_simulator_env = copy.deepcopy(self) next_simulator_env.reset(start_player_index, init_state=new_board) # index - # NOTE: when call reset, self.recent is cleared + # NOTE: when calling reset method, self.recent is cleared, so we need to restore it. next_simulator_env._raw_env._go.recent = tmp_position.recent return next_simulator_env + def random_action(self): return np.random.choice(self.legal_actions) diff --git a/zoo/board_games/go/envs/go_env_bkp.py b/zoo/board_games/go/envs/go_env_bkp.py deleted file mode 100644 index 6b3f07f54..000000000 --- a/zoo/board_games/go/envs/go_env_bkp.py +++ /dev/null @@ -1,330 +0,0 @@ -import os -import sys - -import numpy as np -import pygame -from ding.envs import BaseEnv, BaseEnvTimestep -from ding.utils import ENV_REGISTRY -from gym import spaces -from pettingzoo.classic.go import coords, go -from pettingzoo.utils.agent_selector import agent_selector - - -def get_image(path): - from os import path as os_path - - import pygame - cwd = os_path.dirname(__file__) - image = pygame.image.load(cwd + '/' + path) - sfc = pygame.Surface(image.get_size(), flags=pygame.SRCALPHA) - sfc.blit(image, (0, 0)) - return sfc - - -@ENV_REGISTRY.register('Go') -class GoEnv(BaseEnv): - - def __init__(self, board_size: int = 19, komi: float = 7.5): - # board_size: a int, representing the board size (board has a board_size x board_size shape) - # komi: a float, representing points given to the second player. - # self._overwrite_go_global_variables(board_size=board_size) - self._komi = komi - self.board_size = board_size - self._N = board_size - self.agents = ['black_0', 'white_0'] - self.num_agents = len(self.agents) - - self.possible_agents = self.agents[:] - self.has_reset = False - - self.screen = None - - self._observation_space = self._convert_to_dict( - [ - spaces.Dict( - { - 'observation': spaces.Box(low=0, high=1, shape=(self._N, self._N, 17), dtype=bool), - 'action_mask': spaces.Box(low=0, high=1, shape=((self._N * self._N) + 1, ), dtype=np.int8) - } - ) for _ in range(self.num_agents) - ] - ) - - self._action_space = self._convert_to_dict( - [spaces.Discrete(self._N * self._N + 1) for _ in range(self.num_agents)] - ) - - self._agent_selector = agent_selector(self.agents) - - self.board_history = np.zeros((self._N, self._N, 16), dtype=bool) - - def reset(self): - self.has_reset = True - # self._go = go.Position(board=None, komi=self._komi) - # self._go = go.go_base.Position(board=None, komi=self._komi) - # self._go = go.step(board=None, komi=self._komi) - # self._go._overwrite_go_global_variables(board_size=self.board_size) - # self._overwrite_go_global_variables(board_size=self.board_size) - - # self._go = go.env(board_size=self.board_size, komi=self._komi) - from pettingzoo.classic import go_v5 - self._go = go_v5.env(board_size=self.board_size, komi=self._komi) - - self.agents = self.possible_agents[:] - self._agent_selector.reinit(self.agents) - self.agent_selection = self._agent_selector.reset() - self._cumulative_rewards = self._convert_to_dict(np.array([0.0, 0.0])) - self.rewards = self._convert_to_dict(np.array([0.0, 0.0])) - self.dones = self._convert_to_dict([False for _ in range(self.num_agents)]) - self.infos = self._convert_to_dict([{} for _ in range(self.num_agents)]) - # self.next_legal_moves = self._encode_legal_actions(self._go.all_legal_moves()) - self._last_obs = self.observe(self.agents[0]) - self.board_history = np.zeros((self._N, self._N, 16), dtype=bool) - - self.current_player_index = 0 - - for agent, reward in self.rewards.items(): - self._cumulative_rewards[agent] += reward - - agent = self.agent_selection - current_index = self.agents.index(agent) - self.current_player_index = current_index - obs = self.observe(agent) - return obs - - def step(self, action): - if self.dones[self.agent_selection]: - return self._was_done_step(action) - self._go = self._go.play_move(coords.from_flat(action)) - self._last_obs = self.observe(self.agent_selection) - current_agent_plane, opponent_agent_plane = self._encode_board_planes(self.agent_selection) - self.board_history = np.dstack((current_agent_plane, opponent_agent_plane, self.board_history[:, :, :-2])) - next_player = self._agent_selector.next() - - current_agent = next_player # 'black_0', 'white_0' - current_index = self.agents.index(current_agent) # 0, 1 - self.current_player_index = current_index - - if self._go.is_game_over(): - self.dones = self._convert_to_dict([True for _ in range(self.num_agents)]) - self.rewards = self._convert_to_dict(self._encode_rewards(self._go.result())) - self.next_legal_moves = [self._N * self._N] - else: - self.next_legal_moves = self._encode_legal_actions(self._go.all_legal_moves()) - self.agent_selection = next_player if next_player else self._agent_selector.next() - - # self._accumulate_rewards() - for agent, reward in self.rewards.items(): - self._cumulative_rewards[agent] += reward - # observation, reward, done, info = env.last() - agent = self.agent_selection - current_index = self.agents.index(agent) - self.current_player_index = current_index - observation = self.observe(agent) - return BaseEnvTimestep(observation, self._cumulative_rewards[agent], self.dones[agent], self.infos[agent]) - - def _overwrite_go_global_variables(self, board_size: int): - # self._N = board_size - # go.N = self._N - # go.ALL_COORDS = [(i, j) for i in range(self._N) for j in range(self._N)] - # go.EMPTY_BOARD = np.zeros([self._N, self._N], dtype=np.int8) - # go.NEIGHBORS = { - # (x, y): list(filter(self._check_bounds, [(x + 1, y), (x - 1, y), (x, y + 1), (x, y - 1)])) - # for x, y in go.ALL_COORDS - # } - # go.DIAGONALS = { - # (x, y): list(filter(self._check_bounds, [(x + 1, y + 1), (x + 1, y - 1), (x - 1, y + 1), (x - 1, y - 1)])) - # for x, y in go.ALL_COORDS - # } - # return - self._go._overwrite_go_global_variables(board_size) - - def _check_bounds(self, c): - return 0 <= c[0] < self._N and 0 <= c[1] < self._N - - def _encode_player_plane(self, agent): - if agent == self.possible_agents[0]: - return np.zeros([self._N, self._N], dtype=bool) - else: - return np.ones([self._N, self._N], dtype=bool) - - def _encode_board_planes(self, agent): - agent_factor = go.BLACK if agent == self.possible_agents[0] else go.WHITE - current_agent_plane_idx = np.where(self._go.board == agent_factor) - opponent_agent_plane_idx = np.where(self._go.board == -agent_factor) - current_agent_plane = np.zeros([self._N, self._N], dtype=bool) - opponent_agent_plane = np.zeros([self._N, self._N], dtype=bool) - current_agent_plane[current_agent_plane_idx] = 1 - opponent_agent_plane[opponent_agent_plane_idx] = 1 - return current_agent_plane, opponent_agent_plane - - def _int_to_name(self, ind): - return self.possible_agents[ind] - - def _name_to_int(self, name): - return self.possible_agents.index(name) - - def _convert_to_dict(self, list_of_list): - return dict(zip(self.possible_agents, list_of_list)) - - def _encode_legal_actions(self, actions): - return np.where(actions == 1)[0] - - def _encode_rewards(self, result): - return [1, -1] if result == 1 else [-1, 1] - - @property - def current_player(self): - return self.current_player_index - - @property - def to_play(self): - return self.current_player_index - - - - def observe(self, agent): - player_plane = self._encode_player_plane(agent) - observation = np.dstack((self.board_history, player_plane)) - legal_moves = self.next_legal_moves if agent == self.agent_selection else [] - action_mask = np.zeros((self._N * self._N) + 1, 'int8') - for i in legal_moves: - action_mask[i] = 1 - - return {'observation': observation, 'action_mask': action_mask} - - def set_game_result(self, result_val): - for i, name in enumerate(self.agents): - self.dones[name] = True - result_coef = 1 if i == 0 else -1 - self.rewards[name] = result_val * result_coef - self.infos[name] = {'legal_moves': []} - - - def legal_actions(self): - pass - - def legal_moves(self): - if self._go.is_game_over(): - self.dones = self._convert_to_dict([True for _ in range(self.num_agents)]) - self.rewards = self._convert_to_dict(self._encode_rewards(self._go.result())) - self.next_legal_moves = [self._N * self._N] - else: - self.next_legal_moves = self._encode_legal_actions(self._go.all_legal_moves()) - - return self.next_legal_moves - - def random_action(self): - action_list = self.legal_moves() - return np.random.choice(action_list) - - def bot_action(self): - # TODO - pass - - def human_to_action(self): - """ - Overview: - For multiplayer games, ask the user for a legal action - and return the corresponding action number. - Returns: - An integer from the action space. - """ - # print(self.board) - while True: - try: - print(f"Current available actions for the player {self.to_play()} are:{self.legal_moves()}") - choice = int(input(f"Enter the index of next move for the player {self.to_play()}: ")) - if choice in self.legal_moves(): - break - except KeyboardInterrupt: - sys.exit(0) - except Exception as e: - print("Wrong input, try again") - return choice - - def render(self, mode='human'): - screen_width = 1026 - screen_height = 1026 - - if self.screen is None: - if mode == "human": - pygame.init() - self.screen = pygame.display.set_mode((screen_width, screen_height)) - else: - self.screen = pygame.Surface((screen_width, screen_height)) - if mode == "human": - pygame.event.get() - - size = go.N - - # Load and scale all of the necessary images - tile_size = (screen_width) / size - - black_stone = get_image(os.path.join('../img', 'GoBlackPiece.png')) - black_stone = pygame.transform.scale(black_stone, (int(tile_size * (5 / 6)), int(tile_size * (5 / 6)))) - - white_stone = get_image(os.path.join('../img', 'GoWhitePiece.png')) - white_stone = pygame.transform.scale(white_stone, (int(tile_size * (5 / 6)), int(tile_size * (5 / 6)))) - - tile_img = get_image(os.path.join('../img', 'GO_Tile0.png')) - tile_img = pygame.transform.scale(tile_img, ((int(tile_size * (7 / 6))), int(tile_size * (7 / 6)))) - - # blit board tiles - for i in range(1, size - 1): - for j in range(1, size - 1): - self.screen.blit(tile_img, ((i * (tile_size)), int(j) * (tile_size))) - - for i in range(1, 9): - tile_img = get_image(os.path.join('../img', 'GO_Tile' + str(i) + '.png')) - tile_img = pygame.transform.scale(tile_img, ((int(tile_size * (7 / 6))), int(tile_size * (7 / 6)))) - for j in range(1, size - 1): - if i == 1: - self.screen.blit(tile_img, (0, int(j) * (tile_size))) - elif i == 2: - self.screen.blit(tile_img, ((int(j) * (tile_size)), 0)) - elif i == 3: - self.screen.blit(tile_img, ((size - 1) * (tile_size), int(j) * (tile_size))) - elif i == 4: - self.screen.blit(tile_img, ((int(j) * (tile_size)), (size - 1) * (tile_size))) - if i == 5: - self.screen.blit(tile_img, (0, 0)) - elif i == 6: - self.screen.blit(tile_img, ((size - 1) * (tile_size), 0)) - elif i == 7: - self.screen.blit(tile_img, ((size - 1) * (tile_size), (size - 1) * (tile_size))) - elif i == 8: - self.screen.blit(tile_img, (0, (size - 1) * (tile_size))) - - offset = tile_size * (1 / 6) - # Blit the necessary chips and their positions - for i in range(0, size): - for j in range(0, size): - if self._go.board[i][j] == go.BLACK: - self.screen.blit(black_stone, ((i * (tile_size) + offset), int(j) * (tile_size) + offset)) - elif self._go.board[i][j] == go.WHITE: - self.screen.blit(white_stone, ((i * (tile_size) + offset), int(j) * (tile_size) + offset)) - - if mode == "human": - pygame.display.update() - - observation = np.array(pygame.surfarray.pixels3d(self.screen)) - - return np.transpose(observation, axes=(1, 0, 2)) if mode == "rgb_array" else None - - def observation_space(self): - return self.observation_spaces - - def action_space(self): - return self._action_space - - def seed(self, seed: int, dynamic_seed: bool = True) -> None: - self._seed = seed - self._dynamic_seed = dynamic_seed - np.random.seed(self._seed) - - def close(self) -> None: - pass - - def __repr__(self) -> str: - return "LightZero Go Env" diff --git a/zoo/board_games/go/envs/test_go_env.py b/zoo/board_games/go/envs/test_go_env.py index 48b1f26f0..08a82545b 100644 --- a/zoo/board_games/go/envs/test_go_env.py +++ b/zoo/board_games/go/envs/test_go_env.py @@ -18,63 +18,65 @@ stop_value=1, ) + @pytest.mark.envtest class TestGoEnv: def test_naive(self): env = GoEnv(cfg) - print('NOTE：actions are counted by column, such as action 9, which is the second column and the first row') - obs = env.reset() - print(obs['observation'].shape, obs['action_mask'].shape) - print(obs['observation'], obs['action_mask']) - - actions_black = [0, 2, 0] - actions_white = [1, 6] - # env.render() - for i in range(1000): - print('turn: ', i) - """player 1""" - # action = env.human_to_action() - # action = env.random_action() + test_episodes = 1 + for _ in range(test_episodes): + print('NOTE：actions are counted by column, such as action 9, which is the second column and the first row') + obs = env.reset() + print(obs['observation'].shape, obs['action_mask'].shape) + print(obs['observation'], obs['action_mask']) - action = actions_black[i] - print('player 1 (black_0): ', action) - obs, reward, done, info = env.step(action) - # time.sleep(0.1) + actions_black = [0, 2, 0] + actions_white = [1, 6] - # print(obs, reward, done, info) - assert isinstance(obs, dict) - assert isinstance(done, bool) - assert isinstance(reward, float) - # env.render('board') - env.render('human') + # env.render() - if done: - if reward > 0: - print('player 1 (black_0) win') - elif reward < 0: - print('player 2 (white_0) win') - else: - print('draw') - break + for i in range(1000): + print('turn: ', i) + """player 1""" + # action = env.human_to_action() + action = env.random_action() + # action = actions_black[i] + print('player 1 (black): ', action) + obs, reward, done, info = env.step(action) + time.sleep(0.1) + # print(obs, reward, done, info) + assert isinstance(obs, dict) + assert isinstance(done, bool) + assert isinstance(reward, float) or isinstance(reward, int) + # env.render('board') + env.render('human') - """player 2""" - # action = env.random_action() + if done: + if reward > 0: + print('player 1 (black) win') + elif reward < 0: + print('player 2 (white) win') + else: + print('draw') + break - action = actions_white[i] - print('player 2 (white_0): ', action) - obs, reward, done, info = env.step(action) - # time.sleep(0.1) + """player 2""" + action = env.random_action() + # action = actions_white[i] + print('player 2 (white): ', action) + obs, reward, done, info = env.step(action) + time.sleep(0.1) - # print(obs, reward, done, info) - # env.render('board') - env.render('human') - if done: - if reward > 0: - print('player 2 (white_0) win') - elif reward < 0: - print('player 1 (black_0) win') - else: - print('draw') - break + # print(obs, reward, done, info) + # env.render('board') + env.render('human') + if done: + if reward > 0: + print('player 2 (white) win') + elif reward < 0: + print('player 1 (black) win') + else: + print('draw') + break diff --git a/zoo/board_games/go/envs/test_go_mcts_bot.py b/zoo/board_games/go/envs/test_go_mcts_bot.py index 98f5bb394..b2d8d2057 100644 --- a/zoo/board_games/go/envs/test_go_mcts_bot.py +++ b/zoo/board_games/go/envs/test_go_mcts_bot.py @@ -3,11 +3,13 @@ from zoo.board_games.mcts_bot import MCTSBot import pytest +import time +import numpy as np cfg = EasyDict(dict( # board_size=6, # num_simulations=50, - num_simulations=50, + num_simulations=20, board_size=5, komi=7.5, prob_random_agent=0, @@ -29,194 +31,174 @@ def test_go_mcts_vs_random(self): # player_0 num_simulation=1000, will win # player_1 num_simulation=1 env = GoEnv(cfg) - env.reset() - state = env._raw_env._go.board - player_0 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 + obs = env.reset() + state = obs['board'] + player_1 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 player_index = 0 # player 1 first print('#' * 15) print(state) print('#' * 15) - print('\n') while not env.get_done_reward()[0]: if player_index == 0: - action = player_0.get_actions(state, player_index=player_index) + action = player_1.get_actions(state, player_index=player_index) player_index = 1 else: print('-' * 40) - # action = player_1.get_actions(state, player_index=player_index) + # action = player_2.get_actions(state, player_index=player_index) action = env.random_action() player_index = 0 - # print('-' * 40) - env.step(action) - state = env._raw_env._go.board + + timestep = env.step(action) + # env.render('human') + # time.sleep(0.1) + state = timestep.obs['board'] print('-' * 40) print(state) - # print('#' * 15) assert env.get_done_winner()[1] == 1, f'winner is {env.get_done_winner()[1]}, player 1 should win' - def test_go_self_play_mode_player0_win(self): + def test_go_self_play_mode_player1_win(self): # player_0 num_simulation=1000, will win # player_1 num_simulation=1 env = GoEnv(cfg) - env.reset() - state = env._raw_env._go.board - player_0 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 - player_1 = MCTSBot(GoEnv, cfg, 'player 2', int(cfg.num_simulations/2)) # player_index = 1, player = 2 + obs = env.reset() + state = obs['board'] + player_1 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 + player_2 = MCTSBot(GoEnv, cfg, 'player 2', int(cfg.num_simulations/2)) # player_index = 1, player = 2 player_index = 0 # player 1 first print('#' * 15) print(state) print('#' * 15) - print('\n') while not env.get_done_reward()[0]: if player_index == 0: - action = player_0.get_actions(state, player_index=player_index) + action = player_1.get_actions(state, player_index=player_index) player_index = 1 else: print('-' * 40) - action = player_1.get_actions(state, player_index=player_index) + action = player_2.get_actions(state, player_index=player_index) player_index = 0 - # print('-' * 40) - env.step(action) - state = env._raw_env._go.board + timestep = env.step(action) + state = timestep.obs['board'] print('-' * 40) print(state) - # print('#' * 15) assert env.get_done_winner()[1] == 1, f'winner is {env.get_done_winner()[1]}, player 1 should win' - def test_go_self_play_mode_player1_win(self): + def test_go_self_play_mode_player2_win(self): # player_0 num_simulation=1 # player_1 num_simulation=1000, will win env = GoEnv(cfg) - env.reset() - state = env._raw_env._go.board - player_0 = MCTSBot(GoEnv, cfg, 'player 1', 1) # player_index = 0, player = 1 - player_1 = MCTSBot(GoEnv, cfg, 'player 2', cfg.num_simulations) # player_index = 1, player = 2 + obs = env.reset() + state = obs['board'] + player_1 = MCTSBot(GoEnv, cfg, 'player 1', 1) # player_index = 0, player = 1 + player_2 = MCTSBot(GoEnv, cfg, 'player 2', cfg.num_simulations) # player_index = 1, player = 2 player_index = 0 # player 1 first print('#' * 15) print(state) print('#' * 15) - print('\n') while not env.get_done_reward()[0]: if player_index == 0: - action = player_0.get_actions(state, player_index=player_index) + action = player_1.get_actions(state, player_index=player_index) player_index = 1 else: print('-' * 40) - action = player_1.get_actions(state, player_index=player_index) + action = player_2.get_actions(state, player_index=player_index) player_index = 0 - env.step(action) - state = env._raw_env._go.board + timestep = env.step(action) + state = timestep.obs['board'] print('-' * 40) print(state) assert env.get_done_winner()[1] == 2, f'winner is {env.get_done_winner()[1]}, player 2 should win' - def test_go_self_play_mode_draw(self): # player_0 num_simulation=1000 # player_1 num_simulation=1000, will draw + cfg.num_simulations = 50 + env = GoEnv(cfg) - env.reset() - state = env._raw_env._go.board - player_0 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 - player_1 = MCTSBot(GoEnv, cfg, 'player 2', cfg.num_simulations) # player_index = 1, player = 2 + obs = env.reset() + state = obs['board'] + + player_1 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 + player_2 = MCTSBot(GoEnv, cfg, 'player 2', cfg.num_simulations) # player_index = 1, player = 2 player_index = 0 # player 1 fist - print('#' * 15) print(state) - print('#' * 15) - print('\n') + print('-' * 40) while not env.get_done_reward()[0]: if player_index == 0: - action = player_0.get_actions(state, player_index=player_index) + action = player_1.get_actions(state, player_index=player_index) player_index = 1 else: print('-' * 40) - action = player_1.get_actions(state, player_index=player_index) + action = player_2.get_actions(state, player_index=player_index) player_index = 0 - env.step(action) - state = env._raw_env._go.board + timestep = env.step(action) + + env.render('human') + # time.sleep(0.1) + + state = timestep.obs['board'] print('-' * 40) print(state) assert env.get_done_winner()[1] == -1, f'winner is {env.get_done_winner()[1]}, two players should draw' - # def test_go_self_play_mode_case_1(self): - # env = GoEnv(cfg) - # init_state = [ - # [1, 1, 1, 1, 0], - # [1, 0, 0, 0, 2], - # [0, 0, 2, 0, 2], - # [0, 2, 0, 0, 2], - # [2, 1, 1, 0, 0], - # ] - # player_0 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 - # player_1 = MCTSBot(GoEnv, cfg, 'player 2', cfg.num_simulations) # player_index = 1, player = 2 - # player_index = 1 # player 1 fist - # - # env.reset(player_index, init_state) - # state = env._raw_env._go.board - # - # print('#' * 15) - # print(state) - # print('#' * 15) - # print('\n') - # while not env.get_done_reward()[0]: - # if player_index == 0: - # action = player_0.get_actions(state, player_index=player_index) - # player_index = 1 - # else: - # print('-' * 40) - # action = player_1.get_actions(state, player_index=player_index) - # player_index = 0 - # print('-' * 40) - # env.step(action) - # state = env._raw_env._go.board - # print('#' * 15) - # print(state) - # print('#' * 15) - # row, col = env.action_to_coord(action) - # assert env.get_done_winner()[1] == 2 - # assert state[0, 4] == 2 - # - # def test_go_self_play_mode_case_2(self): - # env = GoEnv(cfg) - # init_state = [ - # [0, 0, 2, 0, 0], - # [0, 1, 2, 0, 0], - # [2, 2, 1, 0, 0], - # [2, 0, 0, 1, 2], - # [1, 1, 1, 0, 0], - # ] - # player_0 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 - # player_1 = MCTSBot(GoEnv, cfg, 'player 2', cfg.num_simulations) # player_index = 1, player = 2 - # player_index = 0 # player 1 fist - # - # env.reset(player_index, init_state) - # state = env._raw_env._go.board - # - # print('#' * 15) - # print(state) - # print('#' * 15) - # print('\n') - # while not env.get_done_reward()[0]: - # if player_index == 0: - # action = player_0.get_actions(state, player_index=player_index) - # player_index = 1 - # else: - # print('-' * 40) - # action = player_1.get_actions(state, player_index=player_index) - # player_index = 0 - # print('-' * 40) - # env.step(action) - # state = env._raw_env._go.board - # print('#' * 15) - # print(state) - # print('#' * 15) - # row, col = env.action_to_coord(action) - # assert env.get_done_winner()[1] == 1 - # assert state[4, 4] == 1 - - -test = TestGoBot().test_go_self_play_mode_player0_win() \ No newline at end of file + def test_go_self_play_mode_case_1(self): + env = GoEnv(cfg) + init_state = np.array([ + [0, 0, 0, -1, -1], + [0, 0, 1, 1, -1], + [0, 1, -1, 1, -1], + [0, 0, 0, 1, -1], + [0, 0, 0, 0, 1], + ]) + + # TODO + cfg.num_simulations = 50 + + player_1 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 + player_2 = MCTSBot(GoEnv, cfg, 'player 2', cfg.num_simulations) # player_index = 1, player = 2 + player_index = 0 # player 1 fist + + obs = env.reset(player_index, init_state) + state = obs['board'] + print(state) + print('#' * 15) + + while not env.get_done_reward()[0]: + if player_index == 0: + action = player_1.get_actions(state, player_index=player_index) + assert action == 2 + + def test_go_self_play_mode_case_2(self): + env = GoEnv(cfg) + init_state = np.array([ + [0, 0, 1, 1, 1], + [0, 0, -1, -1, 1], + [0, 0, 0, -1, 1], + [0, 0, 0, -1, 1], + [0, 0, 0, 0, -1], + ]) + + # TODO + cfg.num_simulations = 50 + + player_1 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 + player_2 = MCTSBot(GoEnv, cfg, 'player 2', cfg.num_simulations) # player_index = 1, player = 2 + player_index = 1 # player 2 fist + + obs = env.reset(player_index, init_state) + state = obs['board'] + print(state) + print('#' * 15) + + while not env.get_done_reward()[0]: + if player_index == 1: + action = player_2.get_actions(state, player_index=player_index) + assert action == 1 + + +# test = TestGoBot().test_go_self_play_mode_player1_win() +test = TestGoBot().test_go_self_play_mode_draw() +# test = TestGoBot().test_go_self_play_mode_case_2() diff --git a/zoo/board_games/mcts_bot.py b/zoo/board_games/mcts_bot.py index e9a7eace2..b36413aa6 100644 --- a/zoo/board_games/mcts_bot.py +++ b/zoo/board_games/mcts_bot.py @@ -78,8 +78,9 @@ def best_child(self, c_param=1.4): self.best_action = self.parent_action[np.argmax(choices_weights)] return self.children[np.argmax(choices_weights)] - def rollout_policy(self, legal_actions, last_legal_actions=None, last_action=None): - if last_legal_actions is not None and last_legal_actions == [self.env.board_size ** 2] and last_action is not None and last_action == self.env.board_size ** 2: + def rollout_policy(self, legal_actions, last_legal_actions=None, last_action=None): + if last_legal_actions is not None and last_legal_actions == [ + self.env.board_size ** 2] and last_action is not None and last_action == self.env.board_size ** 2: # for Go env, if last_action is not None, and last_action == self.env.board_size ** 2, then pass return legal_actions[-1] return legal_actions[np.random.randint(len(legal_actions))] @@ -142,13 +143,11 @@ def rollout(self): # print('simulation begin') current_rollout_env = self.env # print(current_rollout_env.board) - step=0 - last_action=None - last_legal_actions=None + step = 0 + last_action = None + last_legal_actions = None while not current_rollout_env.get_done_reward()[0]: step += 1 - - legal_actions = current_rollout_env.legal_actions action = self.rollout_policy(legal_actions, last_legal_actions, last_action) # print('step={}'.format(step)) @@ -234,7 +233,7 @@ def __init__(self, ENV, cfg, bot_name, num_simulation=10000): def get_actions(self, state, player_index): simulator_env = self.ENV(EasyDict(self.cfg)) simulator_env.reset(start_player_index=player_index, init_state=state) - legal_actions = simulator_env.legal_actions + # legal_actions = simulator_env.legal_actions root = TwoPlayersMCTSNode(simulator_env) mcts = MCTSSearchNode(root) mcts.best_action(self.num_simulation) From 689e1c7bd8225f1bc249b8967ed16d6682848c77 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Fri, 30 Jun 2023 15:05:42 +0800 Subject: [PATCH 17/34] feature(pu): add init versio of katago pure policy based bot (without mcts) --- .../go/config/go_alphazero_bot_mode_config.py | 1 + .../go/config/go_alphazero_eval_config.py | 7 +- .../go/config/go_alphazero_sp_mode_config.py | 10 +- .../envs/eval_go_mcts_bot_speed_win-rate.py | 13 +- zoo/board_games/go/envs/go_env.py | 111 ++- zoo/board_games/go/envs/go_env_bkp.py | 700 +++++++++++++ .../go/envs/katago_play_for_lightzero.py | 931 ++++++++++++++++++ zoo/board_games/go/envs/test_go_mcts_bot.py | 42 +- zoo/board_games/go/envs/test_katago_bot.py | 116 +++ 9 files changed, 1891 insertions(+), 40 deletions(-) create mode 100644 zoo/board_games/go/envs/go_env_bkp.py create mode 100644 zoo/board_games/go/envs/katago_play_for_lightzero.py create mode 100644 zoo/board_games/go/envs/test_katago_bot.py diff --git a/zoo/board_games/go/config/go_alphazero_bot_mode_config.py b/zoo/board_games/go/config/go_alphazero_bot_mode_config.py index 9fc8e0f50..a8b45548e 100644 --- a/zoo/board_games/go/config/go_alphazero_bot_mode_config.py +++ b/zoo/board_games/go/config/go_alphazero_bot_mode_config.py @@ -36,6 +36,7 @@ f'data_az_ptree/gomoku_alphazero_bot-mode_rand{prob_random_action_in_bot}_ns{num_simulations}_upc{update_per_collect}_seed0', env=dict( board_size=board_size, + komi=7.5, battle_mode='play_with_bot_mode', bot_action_type='v0', prob_random_action_in_bot=prob_random_action_in_bot, diff --git a/zoo/board_games/go/config/go_alphazero_eval_config.py b/zoo/board_games/go/config/go_alphazero_eval_config.py index 486c82394..6b06843ce 100644 --- a/zoo/board_games/go/config/go_alphazero_eval_config.py +++ b/zoo/board_games/go/config/go_alphazero_eval_config.py @@ -12,12 +12,13 @@ """ # model_path = './ckpt/ckpt_best.pth.tar' model_path = '/Users/puyuan/code/LightZero/tb_go_b9_sp/ckpt_best.pth.tar' + # model_path = None seeds = [0] - num_episodes_each_seed = 5 + num_episodes_each_seed = 1 # If True, you can play with the agent. - # main_config.env.agent_vs_human = False - main_config.env.agent_vs_human = True + main_config.env.agent_vs_human = False + # main_config.env.agent_vs_human = True create_config.env_manager.type = 'base' main_config.env.evaluator_env_num = 1 diff --git a/zoo/board_games/go/config/go_alphazero_sp_mode_config.py b/zoo/board_games/go/config/go_alphazero_sp_mode_config.py index 774294ca9..7fc1e403a 100644 --- a/zoo/board_games/go/config/go_alphazero_sp_mode_config.py +++ b/zoo/board_games/go/config/go_alphazero_sp_mode_config.py @@ -4,7 +4,7 @@ # ============================================================== # begin of the most frequently changed config specified by the user # ============================================================== -# board_size = 6 +# board_size = 9 # collector_env_num = 8 # n_episode = 8 # evaluator_env_num = 5 @@ -12,7 +12,7 @@ # batch_size = 256 # max_env_step = int(10e6) # prob_random_action_in_bot = 1 -# +# # if board_size == 19: # num_simulations = 800 # elif board_size == 9: @@ -20,7 +20,7 @@ # elif board_size == 6: # num_simulations = 80 -board_size = 6 +board_size = 9 collector_env_num = 1 n_episode = 1 evaluator_env_num = 1 @@ -55,7 +55,9 @@ observation_shape=(board_size, board_size, 17), action_space_size=int(board_size * board_size + 1), num_res_blocks=1, - num_channels=64, + # num_channels=64, + # TODO + num_channels=32, ), cuda=True, board_size=board_size, diff --git a/zoo/board_games/go/envs/eval_go_mcts_bot_speed_win-rate.py b/zoo/board_games/go/envs/eval_go_mcts_bot_speed_win-rate.py index 702e6439f..0b19c6076 100644 --- a/zoo/board_games/go/envs/eval_go_mcts_bot_speed_win-rate.py +++ b/zoo/board_games/go/envs/eval_go_mcts_bot_speed_win-rate.py @@ -7,11 +7,11 @@ import numpy as np -def test_go_mcts_vs_random(num_simulations): +def test_go_mcts_vs_random(num_simulations, eval_episodes): mcts_bot_time_list = [] random_bot_time_list = [] winner = [] - for i in range(10): + for i in range(eval_episodes): print('-' * 10 + 'episode' + str(i) + '-' * 10) # player_0 num_simulation=1000, will win @@ -70,11 +70,11 @@ def test_go_mcts_vs_random(num_simulations): ) -def test_go_mcts_vs_mcts(num_simulations_player_1, num_simulations_player_2): +def test_go_mcts_vs_mcts(num_simulations_player_1, num_simulations_player_2, eval_episodes): mcts_bot_1_time_list = [] mcts_bot_2_time_list = [] winner = [] - for i in range(10): + for i in range(eval_episodes): print('-' * 10 + 'episode' + str(i) + '-' * 10) # player_0 num_simulation=1000, will win @@ -143,6 +143,7 @@ def test_go_mcts_vs_mcts(num_simulations_player_1, num_simulations_player_2): num_simulations=2, num_simulations_player_1=2, num_simulations_player_2=2, + eval_episodes=3, # board_size=6, # komi=2.5, @@ -176,10 +177,10 @@ def test_go_mcts_vs_mcts(num_simulations_player_1, num_simulations_player_2): # ============================================================== # test win rate between mcts_bot and random_bot # ============================================================== - test_go_mcts_vs_random(num_simulations=cfg.num_simulations) + test_go_mcts_vs_random(num_simulations=cfg.num_simulations, eval_episodes=cfg.eval_episodes) # ============================================================== # test win rate between mcts_bot and mcts_bot # ============================================================== test_go_mcts_vs_mcts(num_simulations_player_1=cfg.num_simulations_player_1, - num_simulations_player_2=cfg.num_simulations_player_2) + num_simulations_player_2=cfg.num_simulations_player_2, eval_episodes=cfg.eval_episodes) diff --git a/zoo/board_games/go/envs/go_env.py b/zoo/board_games/go/envs/go_env.py index 90170b10b..8604f5488 100644 --- a/zoo/board_games/go/envs/go_env.py +++ b/zoo/board_games/go/envs/go_env.py @@ -1,8 +1,4 @@ import copy - -from ding.torch_utils import to_list -from ditk import logging - import os import sys from typing import List @@ -11,15 +7,17 @@ import numpy as np import pygame from ding.envs import BaseEnv, BaseEnvTimestep +from ding.torch_utils import to_list from ding.utils import ENV_REGISTRY +from ditk import logging from easydict import EasyDict from gym import spaces -from pettingzoo.classic import go_v5 -from pettingzoo.classic.go.go import raw_env - from pettingzoo.classic.go import coords, go_base +from pettingzoo.classic.go.go import raw_env from pettingzoo.utils.agent_selector import agent_selector +from zoo.board_games.go.envs.katago_play_for_lightzero import katago_move, GameState, str_coord + def get_image(path): from os import path as os_path @@ -143,6 +141,9 @@ def __init__(self, cfg=None): # Represent a board as a numpy array, with 0 empty, 1 is black, -1 is white. def reset(self, start_player_index=0, init_state=None): + # TODO(pu): katago_game_state init + self.katago_game_state = GameState(self.board_size) + self.start_player_index = start_player_index self._current_player = self.players[self.start_player_index] @@ -210,16 +211,6 @@ def _player_step(self, action): action = np.random.choice(self.legal_actions) self._raw_env._go = self._raw_env._go.play_move(coords.from_flat(action)) - # try: - # self._raw_env._go = self._raw_env._go.play_move(coords.from_flat(action)) - # except: - # print('action: ', action) - # print('board:', self._raw_env._go.board) - # import sys - # sys.exit(2) - - # obs = self._go.observe(agent_id) - # obs = self._raw_env.observe(agent_id) obs = self.observe(agent_id) current_agent_plane, opponent_agent_plane = self._raw_env._encode_board_planes(agent_id) @@ -307,8 +298,19 @@ def step(self, action): elif self.battle_mode == 'eval_mode': # player 1 battle with expert player 2 - # player 1's turn + # ****** player 1's turn ****** + # TODO + action = self.random_action() + # ****** update katago internal game state ****** + # TODO(pu): how to avoid this? + katago_flatten_action = self.lz_flatten_to_katago_flatten(action, self.board_size) + print('player 1:', str_coord(katago_flatten_action, self.katago_game_state.board)) + timestep_player1 = self._player_step(action) + print(self.board) + self.update_katago_internal_game_state(katago_flatten_action, to_play=1) + self.show_katago_board() + if self.agent_vs_human: print('player 1 (agent): ' + self.action_to_string(action)) # Note: visualize self.render() @@ -318,14 +320,27 @@ def step(self, action): timestep_player1.obs['to_play'] = -1 return timestep_player1 - # player 2's turn + # ****** player 2's turn ****** if self.agent_vs_human: bot_action = self.human_to_action() else: - bot_action = self.bot_action() - # bot_action = self.random_action() + bot_action = self.get_katago_action(to_play=2) + if bot_action not in self.legal_actions: + logging.warning( + f"You input illegal *bot* action: {bot_action}, the legal_actions are {self.legal_actions}. " + f"Now we randomly choice a action from self.legal_actions." + ) + bot_action = np.random.choice(self.legal_actions) + # ****** update katago internal game state ****** + # TODO(pu): how to avoid this? + katago_flatten_action = self.lz_flatten_to_katago_flatten(bot_action, self.board_size) + print('player 2:', str_coord(katago_flatten_action, self.katago_game_state.board)) + self.update_katago_internal_game_state(katago_flatten_action, to_play=2) timestep_player2 = self._player_step(bot_action) + print(self.board) + # self.show_katago_board() + if self.agent_vs_human: print('player 2 (human): ' + self.action_to_string(bot_action)) # Note: visualize self.render() @@ -340,6 +355,55 @@ def step(self, action): timestep.obs['to_play'] = -1 return timestep + def update_katago_internal_game_state(self, katago_flatten_action, to_play): + # Note: cannot use self.to_play, because self.to_play is updated after the self._player_step(action) + # ****** update internal game state ****** + gtp_action = str_coord(katago_flatten_action, self.katago_game_state.board) + if to_play == 1: + command = ['play', 'b', gtp_action] + else: + command = ['play', 'w', gtp_action] + katago_move(self.katago_game_state, command, to_play) + + def get_katago_action(self, to_play): + command = ['get_katago_action'] + # self.current_player is the player who will play + flatten_action = katago_move(self.katago_game_state, command, to_play=to_play) + return flatten_action + + def show_katago_board(self): + command = ["showboard"] + # self.current_player is the player who will play + katago_move(self.katago_game_state, command) + + def lz_flatten_to_katago_flatten(self, lz_flatten_action, board_size): + """ Convert lz Flattened Coordinate to katago Flattened Coordinate.""" + # self.arrsize = (board_size + 1) * (board_size + 2) + 1 + # xxxxxxxxxx + # .........x + # .........x + # .........x + # .........x + # .........x + # .........x + # .........x + # .........x + # .........x + # xxxxxxxxxx + + if lz_flatten_action == board_size * board_size: + return 0 # Board.PASS_LOC + # convert action index in [0, board_size**2) to coordinate (i, j) + y, x = lz_flatten_action // board_size, lz_flatten_action % board_size + return (board_size + 1) * (y + 1) + x + 1 + # 0 -> (0, 0) -> 11 + # 1 -> (0, 1) -> 12 + # 9 -> (1, 0) -> 21 + + # row = action_number // self.board_size + 1 + # col = action_number % self.board_size + 1 + # return f"Play row {row}, column {col}" + def get_done_winner(self): """ Overview: @@ -509,6 +573,8 @@ def random_action(self): def bot_action(self): return self.random_action() + + def human_to_action(self): """ Overview: @@ -545,7 +611,8 @@ def human_to_action(self): def render(self, mode='human'): if mode == "board": - print(self._raw_env._go.board) + # print(self._raw_env._go.board) + print(self.board) return screen_width = 1026 diff --git a/zoo/board_games/go/envs/go_env_bkp.py b/zoo/board_games/go/envs/go_env_bkp.py new file mode 100644 index 000000000..040a683a4 --- /dev/null +++ b/zoo/board_games/go/envs/go_env_bkp.py @@ -0,0 +1,700 @@ +import copy + +from ding.torch_utils import to_list +from ditk import logging + +import os +import sys +from typing import List + +import gym +import numpy as np +import pygame +from ding.envs import BaseEnv, BaseEnvTimestep +from ding.utils import ENV_REGISTRY +from easydict import EasyDict +from gym import spaces +from pettingzoo.classic.go.go import raw_env + +from pettingzoo.classic.go import coords, go_base +from pettingzoo.utils.agent_selector import agent_selector + + +def get_image(path): + from os import path as os_path + + import pygame + cwd = os_path.dirname(__file__) + image = pygame.image.load(cwd + '/' + path) + sfc = pygame.Surface(image.get_size(), flags=pygame.SRCALPHA) + sfc.blit(image, (0, 0)) + return sfc + + +@ENV_REGISTRY.register('go_lightzero') +class GoEnv(BaseEnv): + """ + Overview: + Go environment. + board: X black, O white, . empty + Represent a board as a numpy array, with 0 empty, 1 is black, -1 is white. + + self._raw_env._go.to_play: 1 black, -1 white + Interface: + reset, step, seed, close, render, close, seed + Property: + action_space, observation_space, reward_range, spec + + """ + + config = dict( + env_name="Go", + battle_mode='self_play_mode', + mcts_mode='self_play_mode', # only used in AlphaZero + bot_action_type='v0', # {'v0', 'alpha_beta_pruning'} + agent_vs_human=False, + prob_random_agent=0, + prob_expert_agent=0, + channel_last=True, + scale=True, + stop_value=1, + ) + + @classmethod + def default_config(cls: type) -> EasyDict: + cfg = EasyDict(copy.deepcopy(cls.config)) + cfg.cfg_type = cls.__name__ + 'Dict' + return cfg + + @property + def current_player(self): + return self._current_player + + @property + def current_player_index(self): + """ + current_player_index = 0, current_player = 1 + current_player_index = 1, current_player = 2 + """ + return 0 if self._current_player == 1 else 1 + + @property + def to_play(self): + """ + current_player_index = 0, current_player = 1, to_play = 2 + current_player_index = 1, current_player = 2, to_play = 1 + """ + return self.players[0] if self.current_player == self.players[1] else self.players[1] + + @property + def current_player_to_compute_bot_action(self): + """ + Overview: to compute expert action easily. + """ + return -1 if self.current_player == 1 else 1 + + # def __init__(self, board_size: int = 19, komi: float = 7.5): + def __init__(self, cfg=None): + + # board_size: a int, representing the board size (board has a board_size x board_size shape) + # komi: a float, representing points given to the second player. + self.cfg = cfg + self.channel_last = cfg.channel_last + self.scale = cfg.scale + self.battle_mode = cfg.battle_mode + # The mode of interaction between the agent and the environment. + assert self.battle_mode in ['self_play_mode', 'play_with_bot_mode', 'eval_mode'] + # The mode of MCTS is only used in AlphaZero. + self.mcts_mode = 'self_play_mode' + + self.board_size = cfg.board_size + self.prob_random_agent = cfg.prob_random_agent + self.prob_random_action_in_bot = cfg.prob_random_action_in_bot + self.channel_last = cfg.channel_last + self.scale = cfg.scale + self.agent_vs_human = cfg.agent_vs_human + self.bot_action_type = cfg.bot_action_type + + self.players = [1, 2] + self.board_markers = [str(i + 1) for i in range(self.board_size)] + self.total_num_actions = self.board_size * self.board_size + 1 + + self._komi = cfg.komi + self.board_size = cfg.board_size + self.agents = ['black_0', 'white_0'] + self.num_agents = len(self.agents) + self.possible_agents = self.agents[:] + self._agent_selector = agent_selector(self.agents) + self.has_reset = False + self.screen = None + + self._observation_space = spaces.Dict( + { + 'observation': spaces.Box(low=0, high=1, shape=(self.board_size, self.board_size, 17), + dtype=bool), + 'action_mask': spaces.Box(low=0, high=1, shape=((self.board_size * self.board_size) + 1,), + dtype=np.int8) + }) + self._action_space = spaces.Discrete(self.board_size * self.board_size + 1) + self._reward_space = gym.spaces.Box(low=0, high=1, shape=(1,), dtype=np.float32) + + self.board_history = np.zeros((self.board_size, self.board_size, 16), dtype=bool) + + # Represent a board as a numpy array, with 0 empty, 1 is black, -1 is white. + def reset(self, start_player_index=0, init_state=None): + self.start_player_index = start_player_index + self._current_player = self.players[self.start_player_index] + + if self.current_player == 1: + agent_id = 'black_0' + self._agent_selector = agent_selector(['black_0', 'white_0']) + elif self.current_player == 2: + agent_id = 'white_0' + self._agent_selector = agent_selector(['white_0', 'black_0']) + + self.agent_selection = self._agent_selector.next() + self._raw_env = raw_env(board_size=self.board_size, komi=self._komi) + self._raw_env.reset() + + if init_state is not None: + # Represent a board as a numpy array, with 0 empty, 1 is black, -1 is white. + # Note, to_play in Position is different from to_play in GoEnv. + self._raw_env._go = go_base.Position(board=copy.deepcopy(init_state), komi=self._komi, + to_play=1 if self.start_player_index == 0 else -1) + else: + self._raw_env._go = go_base.Position(board=np.zeros((self.board_size, self.board_size), dtype="int32"), + komi=self._komi, to_play=1 if self.start_player_index == 0 else -1) + + self._cumulative_rewards = self._convert_to_dict(np.array([0.0, 0.0])) + self.rewards = self._convert_to_dict(np.array([0.0, 0.0])) + + self.dones = self._convert_to_dict([False for _ in range(self.num_agents)]) + self.infos = self._convert_to_dict([{} for _ in range(self.num_agents)]) + + self.next_legal_moves = self._raw_env._encode_legal_actions(self._raw_env._go.all_legal_moves()) + self.board_history = np.zeros((self.board_size, self.board_size, 16), dtype=bool) + + for agent, reward in self.rewards.items(): + self._cumulative_rewards[agent] += reward + + # obs = self._go.observe(agent_id) + # obs = self._raw_env.observe(agent_id) + obs = self.observe(agent_id) + + # obs['action_mask'] is the action mask for the last player + self.action_mask = np.zeros(self.total_num_actions, 'int8') + self.action_mask[self.legal_actions] = 1 + + obs['action_mask'] = self.action_mask + obs['observation'] = obs['observation'].astype(int) + obs['board'] = copy.deepcopy(self._raw_env._go.board) + obs['current_player_index'] = self.current_player_index + obs['to_play'] = self.current_player + + return obs + + def _player_step(self, action): + if self.current_player == 1: + agent_id = 'black_0' + elif self.current_player == 2: + agent_id = 'white_0' + + if action in self.legal_actions: + self._raw_env._go = self._raw_env._go.play_move(coords.from_flat(action)) + else: + logging.warning( + f"You input illegal action: {action}, the legal_actions are {self.legal_actions}. " + f"Now we randomly choice a action from self.legal_actions." + ) + action = np.random.choice(self.legal_actions) + self._raw_env._go = self._raw_env._go.play_move(coords.from_flat(action)) + + # try: + # self._raw_env._go = self._raw_env._go.play_move(coords.from_flat(action)) + # except: + # print('action: ', action) + # print('board:', self._raw_env._go.board) + # import sys + # sys.exit(2) + + # obs = self._go.observe(agent_id) + # obs = self._raw_env.observe(agent_id) + obs = self.observe(agent_id) + + current_agent_plane, opponent_agent_plane = self._raw_env._encode_board_planes(agent_id) + self.board_history = np.dstack((current_agent_plane, opponent_agent_plane, self.board_history[:, :, :-2])) + # self.board_history[:,:,0], self.board_history[:,:,1] + + current_agent = self.agent_selection + # next_player: 'black_0', 'white_0' + """ + NOTE: here exchange the player + """ + self.agent_selection = self._agent_selector.next() + self._current_player = self.to_play + + # obs['action_mask'] is the action mask for the last player + action_mask = np.zeros(self.total_num_actions, 'int8') + action_mask[self.legal_actions] = 1 + obs['action_mask'] = action_mask + obs['observation'] = obs['observation'].astype(int) + obs['board'] = copy.deepcopy(self._raw_env._go.board) + # obs['current_player_index'] = self.players.index(self.current_player) + obs['current_player_index'] = self.current_player_index + obs['to_play'] = self.current_player + + if self._raw_env._go.is_game_over(): + self._raw_env.terminations = self._convert_to_dict( + [True for _ in range(self.num_agents)] + ) + self.rewards = self._convert_to_dict( + self._encode_rewards(self._raw_env._go.result()) + ) + self.next_legal_moves = [self.board_size * self.board_size] + else: + self.next_legal_moves = self._encode_legal_actions(self._raw_env._go.all_legal_moves()) + + for agent, reward in self.rewards.items(): + self._cumulative_rewards[agent] += reward + + agent = self.agent_selection + self.dones[agent] = ( + self._raw_env.terminations[agent] + or self._raw_env.truncations[agent] + ) + if self.dones[agent]: + self.infos[agent]['eval_episode_return'] = self._cumulative_rewards[agent] + + return BaseEnvTimestep(obs, self.rewards[current_agent], self.dones[agent], self.infos[agent]) + + def step(self, action): + if self.battle_mode == 'self_play_mode': + if np.random.rand() < self.prob_random_agent: + action = self.random_action() + timestep = self._player_step(action) + if timestep.done: + # The eval_episode_return is calculated from Player 1's perspective. + timestep.info['eval_episode_return'] = -timestep.reward if timestep.obs[ + 'to_play'] == 1 else timestep.reward + return timestep + elif self.battle_mode == 'play_with_bot_mode': + # player 1 battle with expert player 2 + + # player 1's turn + timestep_player1 = self._player_step(action) + # print('player 1 (efficientzero player): ' + self.action_to_string(action)) # Note: visualize + if timestep_player1.done: + # in play_with_bot_mode, we set to_play as None/-1, because we don't consider the alternation between players + timestep_player1.obs['to_play'] = -1 + return timestep_player1 + + # player 2's turn + bot_action = self.bot_action() + # print('player 2 (expert player): ' + self.action_to_string(bot_action)) # Note: visualize + timestep_player2 = self._player_step(bot_action) + # self.render() # Note: visualize + # the eval_episode_return is calculated from Player 1's perspective + timestep_player2.info['eval_episode_return'] = -timestep_player2.reward + timestep_player2 = timestep_player2._replace(reward=-timestep_player2.reward) + + timestep = timestep_player2 + # NOTE: in play_with_bot_mode, we must set to_play as -1, because we don't consider the alternation between players. + # And the to_play is used in MCTS. + timestep.obs['to_play'] = -1 + return timestep + + elif self.battle_mode == 'eval_mode': + # player 1 battle with expert player 2 + + # player 1's turn + timestep_player1 = self._player_step(action) + if self.agent_vs_human: + print('player 1 (agent): ' + self.action_to_string(action)) # Note: visualize + self.render() + + if timestep_player1.done: + # in eval_mode, we set to_play as None/-1, because we don't consider the alternation between players + timestep_player1.obs['to_play'] = -1 + return timestep_player1 + + # player 2's turn + if self.agent_vs_human: + bot_action = self.human_to_action() + else: + bot_action = self.bot_action() + # bot_action = self.random_action() + + timestep_player2 = self._player_step(bot_action) + if self.agent_vs_human: + print('player 2 (human): ' + self.action_to_string(bot_action)) # Note: visualize + self.render() + + # the eval_episode_return is calculated from Player 1's perspective + timestep_player2.info['eval_episode_return'] = -timestep_player2.reward + timestep_player2 = timestep_player2._replace(reward=-timestep_player2.reward) + + timestep = timestep_player2 + # NOTE: in eval_mode, we must set to_play as -1, because we don't consider the alternation between players. + # And the to_play is used in MCTS. + timestep.obs['to_play'] = -1 + return timestep + + def get_done_winner(self): + """ + Overview: + Check if the game is over and who the winner is. Return 'done' and 'winner'. + Returns: + - outputs (:obj:`Tuple`): Tuple containing 'done' and 'winner', + - if player 1 win, 'done' = True, 'winner' = 1 + - if player 2 win, 'done' = True, 'winner' = 2 + - if draw, 'done' = True, 'winner' = -1 + - if game is not over, 'done' = False, 'winner' = -1 + """ + if self._raw_env._go.is_game_over(): + result = self._raw_env._go.result() + if result == 1: + return True, 1 + elif result == -1: + return True, 2 + elif result == 0: + return True, -1 + else: + return False, -1 + + def get_done_reward(self): + """ + Overview: + Check if the game is over and what is the reward in the perspective of player 1. + Return 'done' and 'reward'. + Returns: + - outputs (:obj:`Tuple`): Tuple containing 'done' and 'reward', + - if player 1 win, 'done' = True, 'reward' = 1 + - if player 2 win, 'done' = True, 'reward' = -1 + - if draw, 'done' = True, 'reward' = 0 + - if game is not over, 'done' = False,'reward' = None + """ + if self._raw_env._go.is_game_over(): + result = self._raw_env._go.result() + if result == 1: + return True, 1 + elif result == -1: + return True, -1 + elif result == 0: + return True, 0 + else: + return False, None + + def observe(self, agent): + current_agent_plane, opponent_agent_plane = self._raw_env._encode_board_planes(agent) + player_plane = self._raw_env._encode_player_plane(agent) + + observation = np.dstack((self.board_history, player_plane)) + + legal_moves = self.next_legal_moves if agent == self.agent_selection else [] + action_mask = np.zeros((self.board_size * self.board_size) + 1, "int8") + for i in legal_moves: + action_mask[i] = 1 + + return {"observation": observation, "action_mask": action_mask} + + def current_state(self): + """ + Overview: + self.board is nd-array, 0 indicates that no stones is placed here, + 1 indicates that player 1's stone is placed here, 2 indicates player 2's stone is placed here + Arguments: + - raw_obs (:obj:`array`): + the 0 dim means which positions is occupied by self.current_player, + the 1 dim indicates which positions are occupied by self.to_play, + the 2 dim indicates which player is the to_play player, 1 means player 1, 2 means player 2 + """ + if self.current_player == 1: + agent_id = 'black_0' + elif self.current_player == 2: + agent_id = 'white_0' + # obs = self._go.observe(agent_id) + # obs = self._raw_env.observe(agent_id) + obs = self.observe(agent_id) + + obs['observation'] = obs['observation'].astype(int) + raw_obs = obs['observation'] + + if self.channel_last: + # (W, H, C) (6, 6, 17) + return raw_obs, raw_obs + else: + # move channel dim to first axis + # (W, H, C) -> (C, W, H) + # e.g. (6, 6, 17) - > (17, 6, 6) + return np.transpose(raw_obs, [2, 0, 1]), np.transpose(raw_obs, [2, 0, 1]) + + @property + def legal_actions(self): + return to_list(self.legal_moves()) + + @property + def board(self): + return self._raw_env._go.board + + def legal_moves(self): + if self._raw_env._go.is_game_over(): + self.terminations = self._convert_to_dict( + [True for _ in range(self.num_agents)] + ) + self.rewards = self._convert_to_dict( + self._encode_rewards(self._raw_env._go.result()) + ) + self.next_legal_moves = [self.board_size * self.board_size] + else: + self.next_legal_moves = self._encode_legal_actions(self._raw_env._go.all_legal_moves()) + + return self.next_legal_moves + + def coord_to_action(self, i, j): + """ + Overview: + convert coordinate i, j to action index a in [0, board_size**2) + """ + return i * self.board_size + j + + def action_to_coord(self, a): + """ + Overview: + convert action index a in [0, board_size**2) to coordinate (i, j) + """ + return a // self.board_size, a % self.board_size + + def action_to_string(self, action_number): + """ + Overview: + Convert an action number to a string representing the action. + Arguments: + - action_number: an integer from the action space. + Returns: + - String representing the action. + """ + row = action_number // self.board_size + 1 + col = action_number % self.board_size + 1 + return f"Play row {row}, column {col}" + + def simulate_action(self, action): + """ + Overview: + execute action and get next_simulator_env. used in AlphaZero. + Returns: + Returns Gomoku instance. + """ + if action not in self.legal_actions: + raise ValueError("action {0} on board {1} is not legal".format(action, self.board)) + if self.start_player_index == 0: + start_player_index = 1 # self.players = [1, 2], start_player = 2, start_player_index = 1 + else: + start_player_index = 0 # self.players = [1, 2], start_player = 1, start_player_index = 0 + # next_simulator_env = copy.deepcopy(self) + raw_env = copy.deepcopy(self._raw_env) + # tmp_position = next_simulator_env._raw_env._go.play_move(coords.from_flat(action)) + tmp_position = raw_env._go.play_move(coords.from_flat(action)) + new_board = copy.deepcopy(tmp_position.board) + next_simulator_env = copy.deepcopy(self) + next_simulator_env.reset(start_player_index, init_state=new_board) # index + # NOTE: when calling reset method, self.recent is cleared, so we need to restore it. + next_simulator_env._raw_env._go.recent = tmp_position.recent + + return next_simulator_env + + def random_action(self): + return np.random.choice(self.legal_actions) + + def bot_action(self): + return self.random_action() + + def katago_action(self): + return self.random_action() + + def human_to_action(self): + """ + Overview: + For multiplayer games, ask the user for a legal action + and return the corresponding action number. + Returns: + An integer from the action space. + """ + # print(self.board) + while True: + try: + row = int( + input( + f"Enter the row (1, 2, ...,{self.board_size}, from up to bottom) to play for the player {self.current_player}: " + ) + ) + col = int( + input( + f"Enter the column (1, 2, ...,{self.board_size}, from left to right) to play for the player {self.current_player}: " + ) + ) + choice = self.coord_to_action(row - 1, col - 1) + if (choice in self.legal_actions and 1 <= row and 1 <= col and row <= self.board_size + and col <= self.board_size): + break + else: + print("Wrong input, try again") + except KeyboardInterrupt: + print("exit") + sys.exit(0) + except Exception as e: + print("Wrong input, try again") + return choice + + def render(self, mode='human'): + if mode == "board": + print(self._raw_env._go.board) + return + + screen_width = 1026 + screen_height = 1026 + + if self.screen is None: + if mode == "human": + pygame.init() + pygame.display.init() + self.screen = pygame.display.set_mode((screen_width, screen_height)) + else: + self.screen = pygame.Surface((screen_width, screen_height)) + if mode == "human": + pygame.event.get() + + size = self.board_size + # Load and scale all of the necessary images + tile_size = (screen_width) / size + + black_stone = get_image(os.path.join('../img', 'GoBlackPiece.png')) + black_stone = pygame.transform.scale(black_stone, (int(tile_size * (5 / 6)), int(tile_size * (5 / 6)))) + + white_stone = get_image(os.path.join('../img', 'GoWhitePiece.png')) + white_stone = pygame.transform.scale(white_stone, (int(tile_size * (5 / 6)), int(tile_size * (5 / 6)))) + + tile_img = get_image(os.path.join('../img', 'GO_Tile0.png')) + tile_img = pygame.transform.scale(tile_img, ((int(tile_size * (7 / 6))), int(tile_size * (7 / 6)))) + + # blit board tiles + for i in range(1, size - 1): + for j in range(1, size - 1): + self.screen.blit(tile_img, ((i * (tile_size)), int(j) * (tile_size))) + + for i in range(1, 9): + tile_img = get_image(os.path.join('../img', 'GO_Tile' + str(i) + '.png')) + tile_img = pygame.transform.scale(tile_img, ((int(tile_size * (7 / 6))), int(tile_size * (7 / 6)))) + for j in range(1, size - 1): + if i == 1: + self.screen.blit(tile_img, (0, int(j) * (tile_size))) + elif i == 2: + self.screen.blit(tile_img, ((int(j) * (tile_size)), 0)) + elif i == 3: + self.screen.blit(tile_img, ((size - 1) * (tile_size), int(j) * (tile_size))) + elif i == 4: + self.screen.blit(tile_img, ((int(j) * (tile_size)), (size - 1) * (tile_size))) + if i == 5: + self.screen.blit(tile_img, (0, 0)) + elif i == 6: + self.screen.blit(tile_img, ((size - 1) * (tile_size), 0)) + elif i == 7: + self.screen.blit(tile_img, ((size - 1) * (tile_size), (size - 1) * (tile_size))) + elif i == 8: + self.screen.blit(tile_img, (0, (size - 1) * (tile_size))) + + offset = tile_size * (1 / 6) + board_tmp = np.transpose(self._raw_env._go.board) + + # Blit the necessary chips and their positions + for i in range(0, size): + for j in range(0, size): + if board_tmp[i][j] == go_base.BLACK: + self.screen.blit(black_stone, ((i * (tile_size) + offset), int(j) * (tile_size) + offset)) + elif board_tmp[i][j] == go_base.WHITE: + self.screen.blit(white_stone, ((i * (tile_size) + offset), int(j) * (tile_size) + offset)) + + if mode == "human": + pygame.display.update() + + observation = np.array(pygame.surfarray.pixels3d(self.screen)) + + return np.transpose(observation, axes=(1, 0, 2)) if mode == "rgb_array" else None + + # def observation_space(self): + # return self.observation_spaces + # + # def action_space(self): + # return self._action_space + + def _check_bounds(self, c): + return 0 <= c[0] < self.board_size and 0 <= c[1] < self.board_size + + def _encode_player_plane(self, agent): + if agent == self.possible_agents[0]: + return np.zeros([self.board_size, self.board_size], dtype=bool) + else: + return np.ones([self.board_size, self.board_size], dtype=bool) + + def _int_to_name(self, ind): + return self.possible_agents[ind] + + def _name_to_int(self, name): + return self.possible_agents.index(name) + + def _convert_to_dict(self, list_of_list): + return dict(zip(self.possible_agents, list_of_list)) + + def _encode_legal_actions(self, actions): + return np.where(actions == 1)[0] + + def _encode_rewards(self, result): + return [1, -1] if result == 1 else [-1, 1] + + def set_game_result(self, result_val): + for i, name in enumerate(self.agents): + self.dones[name] = True + result_coef = 1 if i == 0 else -1 + self.rewards[name] = result_val * result_coef + self.infos[name] = {'legal_moves': []} + + def seed(self, seed: int, dynamic_seed: bool = True) -> None: + self._seed = seed + self._dynamic_seed = dynamic_seed + np.random.seed(self._seed) + + @property + def observation_space(self) -> gym.spaces.Space: + return self._observation_space + + @property + def action_space(self) -> gym.spaces.Space: + return self._action_space + + @property + def reward_space(self) -> gym.spaces.Space: + return self._reward_space + + @current_player.setter + def current_player(self, value): + self._current_player = value + + @staticmethod + def create_collector_env_cfg(cfg: dict) -> List[dict]: + collector_env_num = cfg.pop('collector_env_num') + cfg = copy.deepcopy(cfg) + return [cfg for _ in range(collector_env_num)] + + @staticmethod + def create_evaluator_env_cfg(cfg: dict) -> List[dict]: + evaluator_env_num = cfg.pop('evaluator_env_num') + cfg = copy.deepcopy(cfg) + # In eval phase, we use ``eval_mode`` to make agent play with the built-in bot to + # evaluate the performance of the current agent. + cfg.battle_mode = 'eval_mode' + return [cfg for _ in range(evaluator_env_num)] + + def __repr__(self) -> str: + return "LightZero Go Env" + + def close(self) -> None: + pass diff --git a/zoo/board_games/go/envs/katago_play_for_lightzero.py b/zoo/board_games/go/envs/katago_play_for_lightzero.py new file mode 100644 index 000000000..7d400e4ad --- /dev/null +++ b/zoo/board_games/go/envs/katago_play_for_lightzero.py @@ -0,0 +1,931 @@ +"""Adapted from https://github.com/lightvector/KataGo/blob/master/python/play.py""" + +# !/usr/bin/python3 +import os +import sys + +# 将 Katago 项目的路径添加到 sys.path 中 +sys.path.append(os.path.abspath('/Users/puyuan/code/KataGo/')) +sys.path.append(os.path.abspath('/Users/puyuan/code/KataGo/python')) + +import argparse +import math +import re +import logging +import colorsys +import numpy as np + +import torch +import torch.nn + +from board import Board +from features import Features +from model_pytorch import EXTRA_SCORE_DISTR_RADIUS +from load_model import load_model + +import sys + +description = """ +Play go with a trained neural net! +Implements a basic GTP engine that uses the neural net directly to play moves. +""" + +parser = argparse.ArgumentParser(description=description) +parser.add_argument('-checkpoint', help='Checkpoint to test', required=False) +parser.add_argument('-use-swa', help='Use SWA model', action="store_true", required=False) + +args = vars(parser.parse_args()) + +# TODO(pu) +# download form https://media.katagotraining.org/uploaded/networks/zips/kata1/kata1-b18c384nbt-s6582191360-d3422816034.zip +# unzip to /Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034 +args['checkpoint'] = "/Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt" +# print(args) + +checkpoint_file = args["checkpoint"] +use_swa = args["use_swa"] + +BOARD_SIZE = 6 +# BOARD_SIZE = 9 + +# Hardcoded max board size +pos_len = 19 + +# Model ---------------------------------------------------------------- + +logging.root.handlers = [] +logging.basicConfig( + level=logging.INFO, + format="%(message)s", + handlers=[ + logging.StreamHandler(stream=sys.stderr), + ], +) +np.set_printoptions(linewidth=150) +torch.set_printoptions(precision=7, sci_mode=False, linewidth=100000, edgeitems=1000, threshold=1000000) + +model, swa_model, _ = load_model(checkpoint_file, use_swa, device="cpu", pos_len=pos_len, verbose=True) +model.eval() +model_config = model.config +if swa_model is not None: + model = swa_model.module + model.eval() + +features = Features(model_config, pos_len) + + +class GameState: + def __init__(self, board_size): + self.board_size = board_size + self.board = Board(size=board_size) + self.moves = [] + self.boards = [self.board.copy()] + + +# Moves ---------------------------------------------------------------- + + +def get_outputs(gs, rules): + with torch.no_grad(): + model.eval() + + bin_input_data = np.zeros(shape=[1] + model.bin_input_shape, dtype=np.float32) + global_input_data = np.zeros(shape=[1] + model.global_input_shape, dtype=np.float32) + pla = gs.board.pla + opp = Board.get_opp(pla) + move_idx = len(gs.moves) + # This function assumes N(HW)C order but we actually use NCHW order, so work with it and revert + bin_input_data = np.transpose(bin_input_data, axes=(0, 2, 3, 1)) + bin_input_data = bin_input_data.reshape([1, pos_len * pos_len, -1]) + features.fill_row_features(gs.board, pla, opp, gs.boards, gs.moves, move_idx, rules, bin_input_data, + global_input_data, idx=0) + bin_input_data = bin_input_data.reshape([1, pos_len, pos_len, -1]) + bin_input_data = np.transpose(bin_input_data, axes=(0, 3, 1, 2)) + + # Currently we don't actually do any symmetries + # symmetry = 0 + # model_outputs = model(apply_symmetry(batch["binaryInputNCHW"],symmetry),batch["globalInputNC"]) + + model_outputs = model( + torch.tensor(bin_input_data, dtype=torch.float32), + torch.tensor(global_input_data, dtype=torch.float32), + ) + outputs = model.postprocess_output(model_outputs) + ( + policy_logits, # N, num_policy_outputs, move + value_logits, # N, {win,loss,noresult} + td_value_logits, # N, {long, mid, short} {win,loss,noresult} + pred_td_score, # N, {long, mid, short} + ownership_pretanh, # N, 1, y, x + pred_scoring, # N, 1, y, x + futurepos_pretanh, # N, 2, y, x + seki_logits, # N, 4, y, x + pred_scoremean, # N + pred_scorestdev, # N + pred_lead, # N + pred_variance_time, # N + pred_shortterm_value_error, # N + pred_shortterm_score_error, # N + scorebelief_logits, # N, 2 * (self.pos_len*self.pos_len + EXTRA_SCORE_DISTR_RADIUS) + ) = (x[0] for x in outputs[0]) # N = 0 + + policy0 = torch.nn.functional.softmax(policy_logits[0, :], dim=0).cpu().numpy() + policy1 = torch.nn.functional.softmax(policy_logits[1, :], dim=0).cpu().numpy() + value = torch.nn.functional.softmax(value_logits, dim=0).cpu().numpy() + td_value = torch.nn.functional.softmax(td_value_logits[0, :], dim=0).cpu().numpy() + td_value2 = torch.nn.functional.softmax(td_value_logits[1, :], dim=0).cpu().numpy() + td_value3 = torch.nn.functional.softmax(td_value_logits[2, :], dim=0).cpu().numpy() + scoremean = pred_scoremean.cpu().item() + td_score = pred_td_score.cpu().numpy() + scorestdev = pred_scorestdev.cpu().item() + lead = pred_lead.cpu().item() + vtime = pred_variance_time.cpu().item() + estv = math.sqrt(pred_shortterm_value_error.cpu().item()) + ests = math.sqrt(pred_shortterm_score_error.cpu().item()) + ownership = torch.tanh(ownership_pretanh).cpu().numpy() + scoring = pred_scoring.cpu().numpy() + futurepos = torch.tanh(futurepos_pretanh).cpu().numpy() + seki_probs = torch.nn.functional.softmax(seki_logits[0:3, :, :], dim=0).cpu().numpy() + seki = seki_probs[1] - seki_probs[2] + seki2 = torch.sigmoid(seki_logits[3, :, :]).cpu().numpy() + scorebelief = torch.nn.functional.softmax(scorebelief_logits, dim=0).cpu().numpy() + + board = gs.board + + moves_and_probs0 = [] + for i in range(len(policy0)): + move = features.tensor_pos_to_loc(i, board) + if i == len(policy0) - 1: + moves_and_probs0.append((Board.PASS_LOC, policy0[i])) + elif board.would_be_legal(board.pla, move): + moves_and_probs0.append((move, policy0[i])) + + moves_and_probs1 = [] + for i in range(len(policy1)): + move = features.tensor_pos_to_loc(i, board) + if i == len(policy1) - 1: + moves_and_probs1.append((Board.PASS_LOC, policy1[i])) + elif board.would_be_legal(board.pla, move): + moves_and_probs1.append((move, policy1[i])) + + ownership_flat = ownership.reshape([features.pos_len * features.pos_len]) + ownership_by_loc = [] + board = gs.board + for y in range(board.size): + for x in range(board.size): + loc = board.loc(x, y) + pos = features.loc_to_tensor_pos(loc, board) + if board.pla == Board.WHITE: + ownership_by_loc.append((loc, ownership_flat[pos])) + else: + ownership_by_loc.append((loc, -ownership_flat[pos])) + + scoring_flat = scoring.reshape([features.pos_len * features.pos_len]) + scoring_by_loc = [] + board = gs.board + for y in range(board.size): + for x in range(board.size): + loc = board.loc(x, y) + pos = features.loc_to_tensor_pos(loc, board) + if board.pla == Board.WHITE: + scoring_by_loc.append((loc, scoring_flat[pos])) + else: + scoring_by_loc.append((loc, -scoring_flat[pos])) + + futurepos0_flat = futurepos[0, :, :].reshape([features.pos_len * features.pos_len]) + futurepos0_by_loc = [] + board = gs.board + for y in range(board.size): + for x in range(board.size): + loc = board.loc(x, y) + pos = features.loc_to_tensor_pos(loc, board) + if board.pla == Board.WHITE: + futurepos0_by_loc.append((loc, futurepos0_flat[pos])) + else: + futurepos0_by_loc.append((loc, -futurepos0_flat[pos])) + + futurepos1_flat = futurepos[1, :, :].reshape([features.pos_len * features.pos_len]) + futurepos1_by_loc = [] + board = gs.board + for y in range(board.size): + for x in range(board.size): + loc = board.loc(x, y) + pos = features.loc_to_tensor_pos(loc, board) + if board.pla == Board.WHITE: + futurepos1_by_loc.append((loc, futurepos1_flat[pos])) + else: + futurepos1_by_loc.append((loc, -futurepos1_flat[pos])) + + seki_flat = seki.reshape([features.pos_len * features.pos_len]) + seki_by_loc = [] + board = gs.board + for y in range(board.size): + for x in range(board.size): + loc = board.loc(x, y) + pos = features.loc_to_tensor_pos(loc, board) + if board.pla == Board.WHITE: + seki_by_loc.append((loc, seki_flat[pos])) + else: + seki_by_loc.append((loc, -seki_flat[pos])) + + seki_flat2 = seki2.reshape([features.pos_len * features.pos_len]) + seki_by_loc2 = [] + board = gs.board + for y in range(board.size): + for x in range(board.size): + loc = board.loc(x, y) + pos = features.loc_to_tensor_pos(loc, board) + seki_by_loc2.append((loc, seki_flat2[pos])) + + moves_and_probs = sorted(moves_and_probs0, key=lambda moveandprob: moveandprob[1], reverse=True) + # Generate a random number biased small and then find the appropriate move to make + # Interpolate from moving uniformly to choosing from the triangular distribution + alpha = 1 + beta = 1 + math.sqrt(max(0, len(gs.moves) - 20)) + r = np.random.beta(alpha, beta) + probsum = 0.0 + i = 0 + genmove_result = Board.PASS_LOC + while True: + (move, prob) = moves_and_probs[i] + probsum += prob + if i >= len(moves_and_probs) - 1 or probsum > r: + genmove_result = move + break + i += 1 + + return { + "policy0": policy0, + "policy1": policy1, + "moves_and_probs0": moves_and_probs0, + "moves_and_probs1": moves_and_probs1, + "value": value, + "td_value": td_value, + "td_value2": td_value2, + "td_value3": td_value3, + "scoremean": scoremean, + "td_score": td_score, + "scorestdev": scorestdev, + "lead": lead, + "vtime": vtime, + "estv": estv, + "ests": ests, + "ownership": ownership, + "ownership_by_loc": ownership_by_loc, + "scoring": scoring, + "scoring_by_loc": scoring_by_loc, + "futurepos": futurepos, + "futurepos0_by_loc": futurepos0_by_loc, + "futurepos1_by_loc": futurepos1_by_loc, + "seki": seki, + "seki_by_loc": seki_by_loc, + "seki2": seki2, + "seki_by_loc2": seki_by_loc2, + "scorebelief": scorebelief, + "genmove_result": genmove_result + } + + +def get_input_feature(gs, rules, feature_idx): + board = gs.board + bin_input_data = np.zeros(shape=[1] + model.bin_input_shape, dtype=np.float32) + global_input_data = np.zeros(shape=[1] + model.global_input_shape, dtype=np.float32) + pla = board.pla + opp = Board.get_opp(pla) + move_idx = len(gs.moves) + features.fill_row_features(board, pla, opp, gs.boards, gs.moves, move_idx, rules, bin_input_data, global_input_data, + idx=0) + + locs_and_values = [] + for y in range(board.size): + for x in range(board.size): + loc = board.loc(x, y) + pos = features.loc_to_tensor_pos(loc, board) + locs_and_values.append((loc, bin_input_data[0, pos, feature_idx])) + return locs_and_values + + +def get_pass_alive(board, rules): + pla = board.pla + opp = Board.get_opp(pla) + area = [-1 for i in range(board.arrsize)] + nonPassAliveStones = False + safeBigTerritories = True + unsafeBigTerritories = False + board.calculateArea(area, nonPassAliveStones, safeBigTerritories, unsafeBigTerritories, + rules["multiStoneSuicideLegal"]) + + locs_and_values = [] + for y in range(board.size): + for x in range(board.size): + loc = board.loc(x, y) + locs_and_values.append((loc, area[loc])) + return locs_and_values + + +def get_gfx_commands_for_heatmap(locs_and_values, board, normalization_div, is_percent, value_and_score_from=None, + hotcold=False): + gfx_commands = [] + divisor = 1.0 + if normalization_div == "max": + max_abs_value = max(abs(value) for (loc, value) in locs_and_values) + divisor = max(0.0000000001, max_abs_value) # avoid divide by zero + elif normalization_div is not None: + divisor = normalization_div + + # Caps value at 1.0, using an asymptotic curve + def loose_cap(x): + def transformed_softplus(x): + return -math.log(math.exp(-(x - 1.0) * 8.0) + 1.0) / 8.0 + 1.0 + + base = transformed_softplus(0.0) + return (transformed_softplus(x) - base) / (1.0 - base) + + # Softly curves a value so that it ramps up faster than linear in that range + def soft_curve(x, x0, x1): + p = (x - x0) / (x1 - x0) + + def curve(p): + return math.sqrt(p + 0.16) - 0.4 + + p = curve(p) / curve(1.0) + return x0 + p * (x1 - x0) + + if hotcold: + for (loc, value) in locs_and_values: + if loc != Board.PASS_LOC: + value = value / divisor + + if value < 0: + value = -loose_cap(-value) + else: + value = loose_cap(value) + + interpoints = [ + (-1.00, (0, 0, 0)), + (-0.85, (15, 0, 50)), + (-0.60, (60, 0, 160)), + (-0.35, (0, 0, 255)), + (-0.15, (0, 100, 255)), + (0.00, (115, 115, 115)), + (0.15, (250, 45, 40)), + (0.25, (255, 55, 0)), + (0.60, (255, 255, 20)), + (0.85, (255, 255, 128)), + (1.00, (255, 255, 255)), + ] + + def lerp(p, y0, y1): + return y0 + p * (y1 - y0) + + i = 0 + while i < len(interpoints): + if value <= interpoints[i][0]: + break + i += 1 + i -= 1 + + if i < 0: + (r, g, b) = interpoints[0][1] + if i >= len(interpoints) - 1: + (r, g, b) = interpoints[len(interpoints) - 1][1] + + p = (value - interpoints[i][0]) / (interpoints[i + 1][0] - interpoints[i][0]) + + (r0, g0, b0) = interpoints[i][1] + (r1, g1, b1) = interpoints[i + 1][1] + r = lerp(p, r0, r1) + g = lerp(p, g0, g1) + b = lerp(p, b0, b1) + + r = ("%02x" % int(r)) + g = ("%02x" % int(g)) + b = ("%02x" % int(b)) + gfx_commands.append("COLOR #%s%s%s %s" % (r, g, b, str_coord(loc, board))) + + else: + for (loc, value) in locs_and_values: + if loc != Board.PASS_LOC: + value = value / divisor + if value < 0: + value = -value + huestart = 0.50 + huestop = 0.86 + else: + huestart = -0.02 + huestop = 0.38 + + value = loose_cap(value) + + def lerp(p, x0, x1, y0, y1): + return y0 + (y1 - y0) * (p - x0) / (x1 - x0) + + if value <= 0.03: + hue = huestart + lightness = 0.00 + 0.50 * (value / 0.03) + saturation = value / 0.03 + (r, g, b) = colorsys.hls_to_rgb((hue + 1) % 1, lightness, saturation) + elif value <= 0.60: + hue = lerp(value, 0.03, 0.60, huestart, huestop) + val = 1.0 + saturation = 1.0 + (r, g, b) = colorsys.hsv_to_rgb((hue + 1) % 1, val, saturation) + else: + hue = huestop + lightness = lerp(value, 0.60, 1.00, 0.5, 0.95) + saturation = 1.0 + (r, g, b) = colorsys.hls_to_rgb((hue + 1) % 1, lightness, saturation) + + r = ("%02x" % int(r * 255)) + g = ("%02x" % int(g * 255)) + b = ("%02x" % int(b * 255)) + gfx_commands.append("COLOR #%s%s%s %s" % (r, g, b, str_coord(loc, board))) + + locs_and_values = sorted(locs_and_values, key=lambda loc_and_value: loc_and_value[1]) + locs_and_values_rev = sorted(locs_and_values, key=lambda loc_and_value: loc_and_value[1], reverse=True) + texts = [] + texts_rev = [] + texts_value = [] + maxlen_per_side = 1000 + if len(locs_and_values) > 0 and locs_and_values[0][1] < 0: + maxlen_per_side = 500 + + for i in range(min(len(locs_and_values), maxlen_per_side)): + (loc, value) = locs_and_values[i] + if is_percent: + texts.append("%s %4.1f%%" % (str_coord(loc, board), value * 100)) + else: + texts.append("%s %.3f" % (str_coord(loc, board), value)) + texts.reverse() + + for i in range(min(len(locs_and_values_rev), maxlen_per_side)): + (loc, value) = locs_and_values_rev[i] + if is_percent: + texts_rev.append("%s %4.1f%%" % (str_coord(loc, board), value * 100)) + else: + texts_rev.append("%s %.3f" % (str_coord(loc, board), value)) + + if value_and_score_from is not None: + value = value_and_score_from["value"] + score = value_and_score_from["scoremean"] + lead = value_and_score_from["lead"] + vtime = value_and_score_from["vtime"] + texts_value.append("wv %.2fc nr %.2f%% ws %.1f wl %.1f vt %.1f" % ( + 100 * (value[0] - value[1] if board.pla == Board.WHITE else value[1] - value[0]), + 100 * value[2], + (score if board.pla == Board.WHITE else -score), + (lead if board.pla == Board.WHITE else -lead), + vtime + )) + + gfx_commands.append("TEXT " + ", ".join(texts_value + texts_rev + texts)) + return gfx_commands + + +def print_scorebelief(gs, outputs): + board = gs.board + scorebelief = outputs["scorebelief"] + lead = outputs["lead"] + scoremean = outputs["scoremean"] + scorestdev = outputs["scorestdev"] + + scorebelief = list(scorebelief) + # Flip so that it's in perspective of the player playing + if board.pla != Board.WHITE: + scorebelief.reverse() + scoremean = -scoremean + lead = -lead + + scoredistrmid = pos_len * pos_len + EXTRA_SCORE_DISTR_RADIUS + ret = "" + ret += "TEXT " + ret += "ScoreBelief: \n" + for i in range(17, -1, -1): + ret += "TEXT " + ret += "%+6.1f" % (-(i * 20 + 0.5)) + for j in range(20): + idx = scoredistrmid - (i * 20 + j) - 1 + ret += " %4.0f" % (scorebelief[idx] * 10000) + ret += "\n" + for i in range(18): + ret += "TEXT " + ret += "%+6.1f" % ((i * 20 + 0.5)) + for j in range(20): + idx = scoredistrmid + (i * 20 + j) + ret += " %4.0f" % (scorebelief[idx] * 10000) + ret += "\n" + + beliefscore = 0 + beliefscoresq = 0 + beliefwin = 0 + belieftotal = 0 + for idx in range(scoredistrmid * 2): + score = idx - scoredistrmid + 0.5 + if score > 0: + beliefwin += scorebelief[idx] + else: + beliefwin -= scorebelief[idx] + belieftotal += scorebelief[idx] + beliefscore += score * scorebelief[idx] + beliefscoresq += score * score * scorebelief[idx] + + beliefscoremean = beliefscore / belieftotal + beliefscoremeansq = beliefscoresq / belieftotal + beliefscorevar = max(0, beliefscoremeansq - beliefscoremean * beliefscoremean) + beliefscorestdev = math.sqrt(beliefscorevar) + + ret += "TEXT BeliefWin: %.2fc\n" % (100 * beliefwin / belieftotal) + ret += "TEXT BeliefScoreMean: %.2f\n" % (beliefscoremean) + ret += "TEXT BeliefScoreStdev: %.2f\n" % (beliefscorestdev) + ret += "TEXT Lead: %.3f\n" % (lead) + ret += "TEXT ScoreMean: %.3f\n" % (scoremean) + ret += "TEXT ScoreStdev: %.3f\n" % (scorestdev) + ret += "TEXT Value: %s\n" % str(["%.3f" % x for x in outputs["value"]]) + ret += "TEXT TDValue: %s\n" % str(["%.3f" % x for x in outputs["td_value"]]) + ret += "TEXT TDValue2: %s\n" % str(["%.3f" % x for x in outputs["td_value2"]]) + ret += "TEXT TDValue3: %s\n" % str(["%.3f" % x for x in outputs["td_value3"]]) + ret += "TEXT TDScore: %s\n" % str(["%.3f" % x for x in outputs["td_score"]]) + ret += "TEXT Estv: %s\n" % str(outputs["estv"]) + ret += "TEXT Ests: %s\n" % str(outputs["ests"]) + ret += "TEXT Vtime: %s\n" % str(outputs["vtime"]) + return ret + + +# Basic parsing -------------------------------------------------------- +colstr = 'ABCDEFGHJKLMNOPQRST' + + +def parse_coord(s, board): + """ Covert GTP-coord to (row, col) pair.""" + if s == 'pass': + return Board.PASS_LOC + return board.loc(colstr.index(s[0].upper()), board.size - int(s[1:])) + + +def str_coord(loc, board): + """ Convert katago Flattened Coordinate to GTP-coord.""" + # self.arrsize = (board_size + 1) * (board_size + 2) + 1 + # xxxxxxxxxx + # .........x + # .........x + # .........x + # .........x + # .........x + # .........x + # .........x + # .........x + # .........x + # xxxxxxxxxx + + if loc == Board.PASS_LOC: + return 'pass' + x = board.loc_x(loc) + y = board.loc_y(loc) + return '%c%d' % (colstr[x], board.size - y) + + +def katago_flatten_to_lz_flatten(loc, board): + """ Convert katago Flattened Coordinate to lz Flattened Coordinate.""" + # self.arrsize = (board_size + 1) * (board_size + 2) + 1 + # xxxxxxxxxx + # .........x + # .........x + # .........x + # .........x + # .........x + # .........x + # .........x + # .........x + # .........x + # xxxxxxxxxx + + if loc == Board.PASS_LOC: + # pass + return board.size * board.size + x = board.loc_x(loc) # left_to_right 0,1,2,...,board.size-1 + y = board.loc_y(loc) # upper_to_bottom 0,1,2,...,board.size-1 + return y * board.size + x + # 11 -> (0,0) -> 0 + # 21 -> (0,1) -> 9 + + +# GTP Implementation ----------------------------------------------------- + +# Adapted from https://github.com/pasky/michi/blob/master/michi.py, which is distributed under MIT license +# https://opensource.org/licenses/MIT + +known_commands = [ + 'boardsize', + 'clear_board', + 'showboard', + 'komi', + 'play', + 'genmove', + 'quit', + 'name', + 'version', + 'known_command', + 'list_commands', + 'protocol_version', + 'gogui-analyze_commands', + 'setrule', + 'policy', + 'policy1', + 'logpolicy', + 'ownership', + 'scoring', + 'futurepos0', + 'futurepos1', + 'seki', + 'seki2', + 'scorebelief', + 'passalive', +] +known_analyze_commands = [ + 'gfx/Policy/policy', + 'gfx/Policy1/policy1', + 'gfx/LogPolicy/logpolicy', + 'gfx/Ownership/ownership', + 'gfx/Scoring/scoring', + 'gfx/FuturePos0/futurepos0', + 'gfx/FuturePos1/futurepos1', + 'gfx/Seki/seki', + 'gfx/Seki2/seki2', + 'gfx/ScoreBelief/scorebelief', + 'gfx/PassAlive/passalive', +] + +board_size = BOARD_SIZE + +gs = GameState(board_size) + +rules = { + "koRule": "KO_POSITIONAL", + "scoringRule": "SCORING_AREA", + "taxRule": "TAX_NONE", + # TODO(pu): + "multiStoneSuicideLegal": False, + # "multiStoneSuicideLegal": True, + "hasButton": False, + "encorePhase": 0, + "passWouldEndPhase": False, + "whiteKomi": 7.5, + "asymPowersOfTwo": 0.0, +} + +input_feature_command_lookup = dict() + + +def add_input_feature_visualizations(layer_name, feature_idx, normalization_div): + command_name = layer_name + command_name = command_name.replace("/", ":") + known_commands.append(command_name) + known_analyze_commands.append("gfx/" + command_name + "/" + command_name) + input_feature_command_lookup[command_name] = (feature_idx, normalization_div) + + +for i in range(model.bin_input_shape[1]): + add_input_feature_visualizations("input-" + str(i), i, normalization_div=1) + + +def get_board_matrix_str(matrix, scale, formatstr): + ret = "" + matrix = matrix.reshape([features.pos_len, features.pos_len]) + for y in range(features.pos_len): + for x in range(features.pos_len): + ret += formatstr % (scale * matrix[y, x]) + ret += " " + ret += "\n" + return ret + + +# while True: +def katago_move(game_state, command, to_play=None): + """ + command = ['play', 'b', 'a4'] + command = ['play', 'w', 'a4'] + command = ['genmove', 'w', 'a4'] + command = ['get_katago_action'] + command = ['boardsize', 9] + command = ["showboard"] + + """ + gs = game_state + if re.match('\d+', command[0]): + cmdid = command[0] + command = command[1:] + else: + cmdid = '' + + ret = '' + if command[0] == "showboard": + ret = "\n" + gs.board.to_string().strip() + elif command[0] == "komi": + rules["whiteKomi"] = float(command[1]) + elif command[0] == "play": + pla = (Board.BLACK if command[1] == "B" or command[1] == "b" else Board.WHITE) + loc = parse_coord(command[2], gs.board) + gs.board.play(pla, loc) + gs.moves.append((pla, loc)) + gs.boards.append(gs.board.copy()) + return gs + elif command[0] == "genmove": + outputs = get_outputs(gs, rules) + loc = outputs["genmove_result"] + pla = gs.board.pla + + if len(command) > 1: + pla = (Board.BLACK if command[1] == "B" or command[1] == "b" else Board.WHITE) + gs.board.play(pla, loc) + gs.moves.append((pla, loc)) + gs.boards.append(gs.board.copy()) + ret = str_coord(loc, gs.board) + + elif command[0] == "get_katago_action": + # NOTE: here bot action may be illegal action + outputs = get_outputs(gs, rules) + if to_play == 1: + moves_and_probs0 = outputs["moves_and_probs0"] + moves_and_probs = sorted(moves_and_probs0, key=lambda moveandprob: moveandprob[1], reverse=True) + katago_flatten_action = moves_and_probs[0][0] + elif to_play == 2: + moves_and_probs1 = outputs["moves_and_probs1"] + moves_and_probs = sorted(moves_and_probs1, key=lambda moveandprob: moveandprob[1], reverse=True) + katago_flatten_action = moves_and_probs[0][0] + # gtp_action = str_coord(katago_flatten_action, gs.board) + lz_flatten_action = katago_flatten_to_lz_flatten(katago_flatten_action, gs.board) + return lz_flatten_action + + elif command[0] == "name": + ret = 'KataGo Raw Neural Net Debug/Test Script' + elif command[0] == "version": + ret = '1.0' + elif command[0] == "list_commands": + ret = '\n'.join(known_commands) + elif command[0] == "known_command": + ret = 'true' if command[1] in known_commands else 'false' + elif command[0] == "gogui-analyze_commands": + ret = '\n'.join(known_analyze_commands) + elif command[0] == "setrule": + ret = "" + if command[1] == "korule": + rules["koRule"] = command[2].upper() + elif command[1] == "scoringrule": + rules["scoringRule"] = command[2].upper() + elif command[1] == "taxrule": + rules["taxRule"] = command[2].upper() + elif command[1] == "multistonesuicidelegal": + rules["multiStoneSuicideLegal"] = (command[2].lower() == "true") + elif command[1] == "hasbutton": + rules["hasButton"] = (command[2].lower() == "true") + elif command[1] == "encorephase": + rules["encorePhase"] = int(command[2]) + elif command[1] == "passwouldendphase": + rules["passWouldEndPhase"] = (command[2].lower() == "true") + elif command[1] == "whitekomi" or command[1] == "komi": + rules["whiteKomi"] = float(command[2]) + elif command[1] == "asym": + rules["asymPowersOfTwo"] = float(command[2]) + else: + ret = "Unknown rules setting" + elif command[0] == "policy": + outputs = get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["moves_and_probs0"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=outputs) + ret = "\n".join(gfx_commands) + elif command[0] == "policy1": + outputs = get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["moves_and_probs1"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=outputs) + ret = "\n".join(gfx_commands) + elif command[0] == "logpolicy": + outputs = get_outputs(gs, rules) + moves_and_logprobs = [(move, max(0.0, 4.9 + math.log10(prob))) for (move, prob) in outputs["moves_and_probs0"]] + gfx_commands = get_gfx_commands_for_heatmap(moves_and_logprobs, gs.board, normalization_div=6, is_percent=False, + value_and_score_from=outputs) + ret = "\n".join(gfx_commands) + elif command[0] == "ownership": + outputs = get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["ownership_by_loc"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=None, hotcold=True) + ret = "\n".join(gfx_commands) + elif command[0] == "scoring": + outputs = get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["scoring_by_loc"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=None, hotcold=True) + ret = "\n".join(gfx_commands) + elif command[0] == "futurepos0": + outputs = get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["futurepos0_by_loc"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=None, hotcold=True) + ret = "\n".join(gfx_commands) + elif command[0] == "futurepos1": + outputs = get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["futurepos1_by_loc"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=None, hotcold=True) + ret = "\n".join(gfx_commands) + elif command[0] == "seki": + outputs = get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["seki_by_loc"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=None) + ret = "\n".join(gfx_commands) + elif command[0] == "seki2": + outputs = get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["seki_by_loc2"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=None) + ret = "\n".join(gfx_commands) + + elif command[0] == "policy_raw": + outputs = get_outputs(gs, rules) + ret = "\n" + + policysum = 0.0 + for y in range(gs.board.size): + for x in range(gs.board.size): + loc = gs.board.loc(x, y) + pos = features.loc_to_tensor_pos(loc, gs.board) + gs.board.would_be_legal(gs.board.pla, loc) + policysum += outputs["policy0"][pos] + loc = Board.PASS_LOC + pos = features.loc_to_tensor_pos(loc, gs.board) + policysum += outputs["policy0"][pos] + + for y in range(gs.board.size): + for x in range(gs.board.size): + loc = gs.board.loc(x, y) + pos = features.loc_to_tensor_pos(loc, gs.board) + if gs.board.would_be_legal(gs.board.pla, loc): + ret += "%6.3f" % (100.0 * outputs["policy0"][pos] / policysum) + else: + ret += " - " + ret += " " + ret += "\n" + loc = Board.PASS_LOC + pos = features.loc_to_tensor_pos(loc, gs.board) + ret += "Pass: %6.3f" % (100.0 * outputs["policy0"][pos] / policysum) + + elif command[0] == "policy1_raw": + outputs = get_outputs(gs, rules) + ret = "\n" + + for y in range(gs.board.size): + for x in range(gs.board.size): + loc = gs.board.loc(x, y) + pos = features.loc_to_tensor_pos(loc, gs.board) + if gs.board.would_be_legal(gs.board.pla, loc): + ret += "%6.3f" % (100.0 * outputs["policy1"][pos]) + else: + ret += " - " + ret += " " + ret += "\n" + loc = Board.PASS_LOC + pos = features.loc_to_tensor_pos(loc, gs.board) + ret += "Pass: %6.3f" % (100.0 * outputs["policy1"][pos]) + + elif command[0] == "ownership_raw": + outputs = get_outputs(gs, rules) + ret = get_board_matrix_str(outputs["ownership"], 100.0, "%+7.3f") + elif command[0] == "scoring_raw": + outputs = get_outputs(gs, rules) + ret = get_board_matrix_str(outputs["scoring"], 100.0, "%+7.3f") + elif command[0] == "futurepos0_raw": + outputs = get_outputs(gs, rules) + ret = get_board_matrix_str(outputs["futurepos"][0], 100.0, "%+7.3f") + elif command[0] == "futurepos1_raw": + outputs = get_outputs(gs, rules) + ret = get_board_matrix_str(outputs["futurepos"][1], 100.0, "%+7.3f") + elif command[0] == "seki_raw": + outputs = get_outputs(gs, rules) + ret = get_board_matrix_str(outputs["seki"], 100.0, "%+7.3f") + elif command[0] == "seki2_raw": + outputs = get_outputs(gs, rules) + ret = get_board_matrix_str(outputs["seki2"], 100.0, "%+7.3f") + + elif command[0] in input_feature_command_lookup: + (feature_idx, normalization_div) = input_feature_command_lookup[command[0]] + locs_and_values = get_input_feature(gs, rules, feature_idx) + gfx_commands = get_gfx_commands_for_heatmap(locs_and_values, gs.board, normalization_div, is_percent=False) + ret = "\n".join(gfx_commands) + + elif command[0] == "passalive": + locs_and_values = get_pass_alive(gs.board, rules) + gfx_commands = get_gfx_commands_for_heatmap(locs_and_values, gs.board, normalization_div=None, is_percent=False) + ret = "\n".join(gfx_commands) + + elif command[0] == "scorebelief": + outputs = get_outputs(gs, rules) + ret = print_scorebelief(gs, outputs) + + elif command[0] == "protocol_version": + ret = '2' + elif command[0] == "quit": + print('=%s \n\n' % (cmdid,), end='') + else: + print('Warning: Ignoring unknown command - %s' % (line,), file=sys.stderr) + ret = None + + if ret is not None: + print('=%s %s\n\n' % (cmdid, ret,), end='') + else: + print('?%s ???\n\n' % (cmdid,), end='') + sys.stdout.flush() diff --git a/zoo/board_games/go/envs/test_go_mcts_bot.py b/zoo/board_games/go/envs/test_go_mcts_bot.py index b2d8d2057..d7686778f 100644 --- a/zoo/board_games/go/envs/test_go_mcts_bot.py +++ b/zoo/board_games/go/envs/test_go_mcts_bot.py @@ -7,10 +7,10 @@ import numpy as np cfg = EasyDict(dict( - # board_size=6, - # num_simulations=50, - num_simulations=20, - board_size=5, + board_size=6, + num_simulations=80, + # num_simulations=20, + # board_size=5, komi=7.5, prob_random_agent=0, prob_expert_agent=0, @@ -27,6 +27,36 @@ @pytest.mark.envtest class TestGoBot: + def test_go_mcts_vs_human(self): + # player_0 num_simulation=1000, will win + # player_1 num_simulation=1 + env = GoEnv(cfg) + obs = env.reset() + state = obs['board'] + player_1 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 + + player_index = 0 # player 1 first + print('#' * 15) + print(state) + while not env.get_done_reward()[0]: + if player_index == 0: + action = player_1.get_actions(state, player_index=player_index) + player_index = 1 + else: + print('-' * 40) + # action = player_2.get_actions(state, player_index=player_index) + # action = env.random_action() + action = env.human_to_action() + player_index = 0 + + timestep = env.step(action) + env.render('human') + # time.sleep(0.1) + state = timestep.obs['board'] + print('-' * 40) + print(state) + assert env.get_done_winner()[1] == 1, f'winner is {env.get_done_winner()[1]}, player 1 should win' + def test_go_mcts_vs_random(self): # player_0 num_simulation=1000, will win # player_1 num_simulation=1 @@ -200,5 +230,7 @@ def test_go_self_play_mode_case_2(self): # test = TestGoBot().test_go_self_play_mode_player1_win() -test = TestGoBot().test_go_self_play_mode_draw() +# test = TestGoBot().test_go_self_play_mode_draw() # test = TestGoBot().test_go_self_play_mode_case_2() +test = TestGoBot().test_go_mcts_vs_human() + diff --git a/zoo/board_games/go/envs/test_katago_bot.py b/zoo/board_games/go/envs/test_katago_bot.py new file mode 100644 index 000000000..b1e2b789c --- /dev/null +++ b/zoo/board_games/go/envs/test_katago_bot.py @@ -0,0 +1,116 @@ +import logging + +import numpy as np +import pytest +from easydict import EasyDict + +from zoo.board_games.go.envs.go_env import GoEnv +from zoo.board_games.go.envs.katago_play_for_lightzero import str_coord + +cfg = EasyDict( + # board_size=9, + board_size=6, + + komi=7.5, + battle_mode='self_play_mode', + prob_random_agent=0, + channel_last=False, + scale=True, + agent_vs_human=False, + bot_action_type='v0', + prob_random_action_in_bot=0., + check_action_to_connect4_in_bot_v0=False, + stop_value=1, +) + + +@pytest.mark.envtest +class TestKataGoBot: + + def test_katago_bot(self): + + env = GoEnv(cfg) + test_episodes = 1 + for _ in range(test_episodes): + print('NOTE：actions are counted by column, such as action 9, which is the second column and the first row') + obs = env.reset() + print(obs['observation'].shape, obs['action_mask'].shape) + print(obs['observation'], obs['action_mask']) + actions_black = [0, 2, 0] + actions_white = [1, 6] + # env.render() + # TODO(pu): katago_game_state init + turn = 0 + while True: + turn += 1 + print('turn: ', turn) + # ****** player 1's turn ****** + bot_action = env.get_katago_action(to_play=1) + if bot_action not in env.legal_actions: + logging.warning( + f"You input illegal *bot* action: {bot_action}, the legal_actions are {env.legal_actions}. " + f"Now we randomly choice a action from self.legal_actions." + ) + bot_action = np.random.choice(env.legal_actions) + # ****** update katago internal game state ****** + # TODO(pu): how to avoid this? + katago_flatten_action = env.lz_flatten_to_katago_flatten(bot_action, env.board_size) + print('player 1:', str_coord(katago_flatten_action, env.katago_game_state.board)) + env.update_katago_internal_game_state(katago_flatten_action, to_play=1) + action = bot_action + # action = env.human_to_action() + # action = env.random_action() + # action = actions_black[i] + # print('player 1 (black): ', action) + obs, reward, done, info = env.step(action) + # time.sleep(0.1) + # print(obs, reward, done, info) + assert isinstance(obs, dict) + assert isinstance(done, bool) + assert isinstance(reward, float) or isinstance(reward, int) + # env.render('board') + env.render('human') + + if done: + if reward > 0: + print('player 1 (black) win') + elif reward < 0: + print('player 2 (white) win') + else: + print('draw') + break + + # ****** player 2's turn ****** + bot_action = env.get_katago_action(to_play=2) + if bot_action not in env.legal_actions: + logging.warning( + f"You input illegal *bot* action: {bot_action}, the legal_actions are {env.legal_actions}. " + f"Now we randomly choice a action from self.legal_actions." + ) + bot_action = np.random.choice(env.legal_actions) + # ****** update katago internal game state ****** + # TODO(pu): how to avoid this? + katago_flatten_action = env.lz_flatten_to_katago_flatten(bot_action, env.board_size) + print('player 2:', str_coord(katago_flatten_action, env.katago_game_state.board)) + env.update_katago_internal_game_state(katago_flatten_action, to_play=2) + # action = env.random_action() + action = bot_action + + # action = actions_white[i] + # print('player 2 (white): ', action) + obs, reward, done, info = env.step(action) + # time.sleep(0.1) + # print(self.board) + # print(obs, reward, done, info) + # env.render('board') + env.render('human') + if done: + if reward > 0: + print('player 2 (white) win') + elif reward < 0: + print('player 1 (black) win') + else: + print('draw') + break + +TestKataGoBot().test_katago_bot() \ No newline at end of file From 51df0d50b1289b81b9d74ed0aa25994013dcc1e8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Thu, 6 Jul 2023 04:42:08 +0800 Subject: [PATCH 18/34] polish(pu): polish katago_policy, polish test_katago_bot, fix go_env reward bug --- lzero/policy/alphazero.py | 2 + .../go/config/go_alphazero_bot_mode_config.py | 1 + .../go/config/go_alphazero_eval_config.py | 5 +- .../go/config/go_alphazero_sp_mode_config.py | 66 +- zoo/board_games/go/envs/go_env.py | 243 ++++- .../go/envs/katago_play_for_lightzero.py | 931 ----------------- zoo/board_games/go/envs/katago_policy.py | 950 ++++++++++++++++++ zoo/board_games/go/envs/test_go_mcts_bot.py | 355 ++++--- zoo/board_games/go/envs/test_katago_bot.py | 42 +- zoo/board_games/gomoku/envs/gomoku_env.py | 2 +- zoo/board_games/mcts_bot.py | 2 +- .../tictactoe/envs/tictactoe_env.py | 2 +- 12 files changed, 1413 insertions(+), 1188 deletions(-) delete mode 100644 zoo/board_games/go/envs/katago_play_for_lightzero.py create mode 100644 zoo/board_games/go/envs/katago_policy.py diff --git a/lzero/policy/alphazero.py b/lzero/policy/alphazero.py index 2d6b13a7e..4ddbfaa9f 100644 --- a/lzero/policy/alphazero.py +++ b/lzero/policy/alphazero.py @@ -236,6 +236,7 @@ def _forward_collect(self, envs: Dict, obs: Dict, temperature: float = 1) -> Dic envs[env_id].reset( start_player_index=start_player_index[env_id], init_state=init_state[env_id], + katago_policy_init=False, ) action, mcts_probs = self._collect_mcts.get_next_action( envs[env_id], @@ -282,6 +283,7 @@ def _forward_eval(self, envs: Dict, obs: Dict) -> Dict[str, torch.Tensor]: envs[env_id].reset( start_player_index=start_player_index[env_id], init_state=init_state[env_id], + katago_policy_init=False, ) action, mcts_probs = self._eval_mcts.get_next_action( envs[env_id], policy_forward_fn=self._policy_value_fn, temperature=1.0, sample=False diff --git a/zoo/board_games/go/config/go_alphazero_bot_mode_config.py b/zoo/board_games/go/config/go_alphazero_bot_mode_config.py index a8b45548e..af6c1ef03 100644 --- a/zoo/board_games/go/config/go_alphazero_bot_mode_config.py +++ b/zoo/board_games/go/config/go_alphazero_bot_mode_config.py @@ -37,6 +37,7 @@ env=dict( board_size=board_size, komi=7.5, + katago_checkpoint_path="/Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", battle_mode='play_with_bot_mode', bot_action_type='v0', prob_random_action_in_bot=prob_random_action_in_bot, diff --git a/zoo/board_games/go/config/go_alphazero_eval_config.py b/zoo/board_games/go/config/go_alphazero_eval_config.py index 6b06843ce..a95d0c5bb 100644 --- a/zoo/board_games/go/config/go_alphazero_eval_config.py +++ b/zoo/board_games/go/config/go_alphazero_eval_config.py @@ -15,12 +15,15 @@ # model_path = None seeds = [0] - num_episodes_each_seed = 1 + num_episodes_each_seed = 3 # If True, you can play with the agent. main_config.env.agent_vs_human = False # main_config.env.agent_vs_human = True + main_config.env.save_gif_replay = True + main_config.env.render_in_ui = True create_config.env_manager.type = 'base' + main_config.env.collector_env_num = 1 main_config.env.evaluator_env_num = 1 main_config.env.n_evaluator_episode = 1 total_test_episodes = num_episodes_each_seed * len(seeds) diff --git a/zoo/board_games/go/config/go_alphazero_sp_mode_config.py b/zoo/board_games/go/config/go_alphazero_sp_mode_config.py index 7fc1e403a..c11ad86a5 100644 --- a/zoo/board_games/go/config/go_alphazero_sp_mode_config.py +++ b/zoo/board_games/go/config/go_alphazero_sp_mode_config.py @@ -4,43 +4,51 @@ # ============================================================== # begin of the most frequently changed config specified by the user # ============================================================== +board_size = 6 # board_size = 9 -# collector_env_num = 8 -# n_episode = 8 -# evaluator_env_num = 5 -# update_per_collect = 50 -# batch_size = 256 -# max_env_step = int(10e6) -# prob_random_action_in_bot = 1 -# -# if board_size == 19: -# num_simulations = 800 -# elif board_size == 9: -# num_simulations = 180 -# elif board_size == 6: -# num_simulations = 80 -board_size = 9 -collector_env_num = 1 -n_episode = 1 -evaluator_env_num = 1 -num_simulations = 2 -update_per_collect = 2 -batch_size = 2 -max_env_step = int(5e5) -prob_random_action_in_bot = 0. +if board_size in [9, 19]: + komi = 7.5 +elif board_size == 6: + komi = 4 + +collector_env_num = 8 +n_episode = 8 +evaluator_env_num = 2 +update_per_collect = 50 +batch_size = 256 +max_env_step = int(10e6) + +if board_size == 19: + num_simulations = 800 +elif board_size == 9: + num_simulations = 180 +elif board_size == 6: + num_simulations = 80 + +# board_size = 9 +# collector_env_num = 1 +# n_episode = 1 +# evaluator_env_num = 1 +# num_simulations = 2 +# update_per_collect = 2 +# batch_size = 2 +# max_env_step = int(5e5) +# prob_random_action_in_bot = 0. # ============================================================== # end of the most frequently changed config specified by the user # ============================================================== go_alphazero_config = dict( exp_name= - f'data_az_ptree/go_b{board_size}_alphazero_sp-mode_rand{prob_random_action_in_bot}_ns{num_simulations}_upc{update_per_collect}_seed0', + f'data_az_ptree/go_b{board_size}-komi-{komi}_alphazero_sp-mode_ns{num_simulations}_upc{update_per_collect}_seed0', env=dict( board_size=board_size, - komi=7.5, + komi=komi, + katago_checkpoint_path="/Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", + # katago_checkpoint_path="/mnt/nfs/puyuan/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", battle_mode='self_play_mode', bot_action_type='v0', - prob_random_action_in_bot=prob_random_action_in_bot, + prob_random_action_in_bot=0, channel_last=True, collector_env_num=collector_env_num, evaluator_env_num=evaluator_env_num, @@ -55,9 +63,9 @@ observation_shape=(board_size, board_size, 17), action_space_size=int(board_size * board_size + 1), num_res_blocks=1, - # num_channels=64, - # TODO - num_channels=32, + num_channels=64, + # TODO: + # num_channels=32, ), cuda=True, board_size=board_size, diff --git a/zoo/board_games/go/envs/go_env.py b/zoo/board_games/go/envs/go_env.py index 8604f5488..90eb9b194 100644 --- a/zoo/board_games/go/envs/go_env.py +++ b/zoo/board_games/go/envs/go_env.py @@ -16,7 +16,9 @@ from pettingzoo.classic.go.go import raw_env from pettingzoo.utils.agent_selector import agent_selector -from zoo.board_games.go.envs.katago_play_for_lightzero import katago_move, GameState, str_coord +from zoo.board_games.go.envs.katago_policy_for_lightzero import str_coord, GameState, str_coord, KatagoPolicy +import imageio +import time def get_image(path): @@ -30,6 +32,32 @@ def get_image(path): return sfc +from datetime import datetime + + +def generate_gif_filename(prefix="go", extension=".gif"): + current_time = datetime.now() + timestamp = current_time.strftime("%Y%m%d-%H%M%S") + filename = f"{prefix}-{timestamp}{extension}" + return filename + +def flatten_action_to_gtp_action(flatten_action, board_size): + if flatten_action == board_size * board_size: + return "pass" + + row = board_size - 1 - (flatten_action // board_size) + col = flatten_action % board_size + + # 跳过字母 'I' + if col >= ord('I') - ord('A'): + col += 1 + + col_str = chr(col + ord('A')) + row_str = str(row + 1) + + gtp_action = col_str + row_str + return gtp_action + @ENV_REGISTRY.register('go_lightzero') class GoEnv(BaseEnv): """ @@ -43,20 +71,25 @@ class GoEnv(BaseEnv): reset, step, seed, close, render, close, seed Property: action_space, observation_space, reward_range, spec - """ config = dict( env_name="Go", + stop_value=1, + board_size=6, + komi=7.5, battle_mode='self_play_mode', mcts_mode='self_play_mode', # only used in AlphaZero + save_gif_replay=False, + save_gif_path='./', + render_in_ui=False, bot_action_type='v0', # {'v0', 'alpha_beta_pruning'} agent_vs_human=False, prob_random_agent=0, prob_expert_agent=0, channel_last=True, scale=True, - stop_value=1, + ignore_pass_if_have_other_legal_actions=True, ) @classmethod @@ -92,7 +125,6 @@ def current_player_to_compute_bot_action(self): """ return -1 if self.current_player == 1 else 1 - # def __init__(self, board_size: int = 19, komi: float = 7.5): def __init__(self, cfg=None): # board_size: a int, representing the board size (board has a board_size x board_size shape) @@ -139,11 +171,26 @@ def __init__(self, cfg=None): self.board_history = np.zeros((self.board_size, self.board_size, 16), dtype=bool) - # Represent a board as a numpy array, with 0 empty, 1 is black, -1 is white. - def reset(self, start_player_index=0, init_state=None): - # TODO(pu): katago_game_state init - self.katago_game_state = GameState(self.board_size) + self.save_gif_replay = cfg.save_gif_replay + self.render_in_ui = cfg.render_in_ui + self.katago_checkpoint_path= cfg.katago_checkpoint_path + self.ignore_pass_if_have_other_legal_actions = cfg.ignore_pass_if_have_other_legal_actions + + self.katago_policy = KatagoPolicy(checkpoint_path=self.katago_checkpoint_path, board_size=self.board_size, + ignore_pass_if_have_other_legal_actions=self.ignore_pass_if_have_other_legal_actions) + # Represent a board as a numpy array, with 0 empty, 1 is black, -1 is white. + def reset(self, start_player_index=0, init_state=None, katago_policy_init=True): + if katago_policy_init: + # 使用函数生成基于当前时间的 GIF 文件名 + gif_filename = generate_gif_filename(prefix=f"go_bs{self.board_size}", ) + # print(gif_filename) + self.save_gif_path = self.cfg.save_gif_path + gif_filename + self.frames = [] + # TODO(pu): katago_game_state init + self.katago_game_state = GameState(self.board_size) + + self.len_of_legal_actions_for_current_player = self.board_size*self.board_size+1 self.start_player_index = start_player_index self._current_player = self.players[self.start_player_index] @@ -200,6 +247,13 @@ def _player_step(self, action): agent_id = 'black_0' elif self.current_player == 2: agent_id = 'white_0' + # the count of empty position + zero_count = np.count_nonzero(self.board == 0) + if zero_count == 1: + # must give pass + action = self.board_size*self.board_size # pass + + self.len_of_legal_actions_for_current_player = len(self.legal_actions) if action in self.legal_actions: self._raw_env._go = self._raw_env._go.play_move(coords.from_flat(action)) @@ -223,6 +277,7 @@ def _player_step(self, action): NOTE: here exchange the player """ self.agent_selection = self._agent_selector.next() + next_agent = self.agent_selection self._current_player = self.to_play # obs['action_mask'] is the action mask for the last player @@ -242,24 +297,41 @@ def _player_step(self, action): self.rewards = self._convert_to_dict( self._encode_rewards(self._raw_env._go.result()) ) + # TODO(pu): modify the self._raw_env._go.result() + # if self.len_of_legal_actions_for_last_player > 1 and self.len_of_legal_actions_for_current_player == 1: + # # The last player has other legal actions but chooses to pass, and the current player only has one legal action, which is to pass. + # # This indicates that the last player wins. + # self.rewards[current_agent] = -1 + # self.rewards[next_agent] = 1 + # print(f'current_agent: {current_agent}', f'self.len_of_legal_actions_for_last_player: {self.len_of_legal_actions_for_last_player}, ' + # f'self.len_of_legal_actions_for_current_player: {self.len_of_legal_actions_for_current_player}') + self.next_legal_moves = [self.board_size * self.board_size] else: self.next_legal_moves = self._encode_legal_actions(self._raw_env._go.all_legal_moves()) + self.len_of_legal_actions_for_last_player = self.len_of_legal_actions_for_current_player + for agent, reward in self.rewards.items(): self._cumulative_rewards[agent] += reward - agent = self.agent_selection - self.dones[agent] = ( - self._raw_env.terminations[agent] - or self._raw_env.truncations[agent] + + self.dones[current_agent] = ( + self._raw_env.terminations[current_agent] + or self._raw_env.truncations[current_agent] ) - if self.dones[agent]: - self.infos[agent]['eval_episode_return'] = self._cumulative_rewards[agent] + if self.dones[current_agent]: + self.infos[current_agent]['eval_episode_return'] = self._cumulative_rewards[current_agent] - return BaseEnvTimestep(obs, self.rewards[current_agent], self.dones[agent], self.infos[agent]) + # The returned reward and done is calculated from current_agent's perspective. + return BaseEnvTimestep(obs, self.rewards[current_agent], self.dones[current_agent], self.infos[current_agent]) def step(self, action): + if self.save_gif_replay and not self.render_in_ui: + self.render_and_capture_frame(mode='only_save_gif') + if self.save_gif_replay and self.render_in_ui: + self.render_and_capture_frame(mode='render_in_ui') + if self.battle_mode == 'self_play_mode': if np.random.rand() < self.prob_random_agent: action = self.random_action() @@ -268,6 +340,10 @@ def step(self, action): # The eval_episode_return is calculated from Player 1's perspective. timestep.info['eval_episode_return'] = -timestep.reward if timestep.obs[ 'to_play'] == 1 else timestep.reward + if self.save_gif_replay and len(self.frames) > 0: + # Save the frames as a GIF file + self.save_gif(self.save_gif_path) + return timestep elif self.battle_mode == 'play_with_bot_mode': # player 1 battle with expert player 2 @@ -278,7 +354,10 @@ def step(self, action): if timestep_player1.done: # in play_with_bot_mode, we set to_play as None/-1, because we don't consider the alternation between players timestep_player1.obs['to_play'] = -1 - return timestep_player1 + + if self.save_gif_replay: + # Save the frames as a GIF file + self.save_gif(self.save_gif_path) # player 2's turn bot_action = self.bot_action() @@ -296,33 +375,41 @@ def step(self, action): return timestep elif self.battle_mode == 'eval_mode': - # player 1 battle with expert player 2 + # player 1 battle with bot player 2 - # ****** player 1's turn ****** - # TODO - action = self.random_action() + # ============================================================== + # player 1's turn + # ============================================================== # ****** update katago internal game state ****** # TODO(pu): how to avoid this? katago_flatten_action = self.lz_flatten_to_katago_flatten(action, self.board_size) - print('player 1:', str_coord(katago_flatten_action, self.katago_game_state.board)) - - timestep_player1 = self._player_step(action) - print(self.board) + # print('player 1:', str_coord(katago_flatten_action, self.katago_game_state.board)) self.update_katago_internal_game_state(katago_flatten_action, to_play=1) - self.show_katago_board() - if self.agent_vs_human: - print('player 1 (agent): ' + self.action_to_string(action)) # Note: visualize - self.render() + timestep_player1 = self._player_step(action) + # print(self.board) + # self.show_katago_board() if timestep_player1.done: # in eval_mode, we set to_play as None/-1, because we don't consider the alternation between players timestep_player1.obs['to_play'] = -1 + + if self.save_gif_replay: + # Save the frames as a GIF file + self.save_gif(self.save_gif_path) + return timestep_player1 - # ****** player 2's turn ****** if self.agent_vs_human: - bot_action = self.human_to_action() + print('player 1 (alphazero): ' + self.action_to_string(action)) # Note: visualize + self.render() + + # ============================================================== + # player 2's turn + # ============================================================== + if self.agent_vs_human: + # bot_action = self.human_to_action() + bot_action = self.human_to_gtp_action() else: bot_action = self.get_katago_action(to_play=2) if bot_action not in self.legal_actions: @@ -334,13 +421,18 @@ def step(self, action): # ****** update katago internal game state ****** # TODO(pu): how to avoid this? katago_flatten_action = self.lz_flatten_to_katago_flatten(bot_action, self.board_size) - print('player 2:', str_coord(katago_flatten_action, self.katago_game_state.board)) + # print('player 2:', str_coord(katago_flatten_action, self.katago_game_state.board)) self.update_katago_internal_game_state(katago_flatten_action, to_play=2) timestep_player2 = self._player_step(bot_action) - print(self.board) + # print(self.board) # self.show_katago_board() + if timestep_player2.done: + if self.save_gif_replay: + # Save the frames as a GIF file + self.save_gif(self.save_gif_path) + if self.agent_vs_human: print('player 2 (human): ' + self.action_to_string(bot_action)) # Note: visualize self.render() @@ -363,18 +455,18 @@ def update_katago_internal_game_state(self, katago_flatten_action, to_play): command = ['play', 'b', gtp_action] else: command = ['play', 'w', gtp_action] - katago_move(self.katago_game_state, command, to_play) + self.katago_policy.katago_command(self.katago_game_state, command, to_play) def get_katago_action(self, to_play): command = ['get_katago_action'] # self.current_player is the player who will play - flatten_action = katago_move(self.katago_game_state, command, to_play=to_play) + flatten_action = self.katago_policy.katago_command(self.katago_game_state, command, to_play=to_play) return flatten_action def show_katago_board(self): command = ["showboard"] # self.current_player is the player who will play - katago_move(self.katago_game_state, command) + self.katago_policy.katago_command(self.katago_game_state, command) def lz_flatten_to_katago_flatten(self, lz_flatten_action, board_size): """ Convert lz Flattened Coordinate to katago Flattened Coordinate.""" @@ -561,7 +653,7 @@ def simulate_action(self, action): tmp_position = raw_env._go.play_move(coords.from_flat(action)) new_board = copy.deepcopy(tmp_position.board) next_simulator_env = copy.deepcopy(self) - next_simulator_env.reset(start_player_index, init_state=new_board) # index + next_simulator_env.reset(start_player_index, init_state=new_board, katago_policy_init=False) # index # NOTE: when calling reset method, self.recent is cleared, so we need to restore it. next_simulator_env._raw_env._go.recent = tmp_position.recent @@ -573,8 +665,6 @@ def random_action(self): def bot_action(self): return self.random_action() - - def human_to_action(self): """ Overview: @@ -609,7 +699,55 @@ def human_to_action(self): print("Wrong input, try again") return choice - def render(self, mode='human'): + def human_to_gtp_action(self): + """ + Overview: + For multiplayer games, ask the user for a legal action + and return the corresponding action number. + Returns: + An integer from the action space. + """ + while True: + try: + gtp_action = str( + input( + f"Enter the GTP action to play for the player {self.current_player}: " + ) + ) + + flatten_action = self.gtp_action_to_flatten_action(gtp_action, board_size=self.board_size) + if flatten_action in self.legal_actions: + break + else: + print("Wrong input, try again") + except KeyboardInterrupt: + print("exit") + sys.exit(0) + except Exception as e: + print("Wrong input, try again") + return flatten_action + + def gtp_action_to_flatten_action(self, gtp_action, board_size): + if gtp_action.lower() == "pass": + return board_size * board_size + + col_str, row_str = gtp_action[0], gtp_action[1:] + col = ord(col_str.upper()) - ord('A') + if col >= ord('I') - ord('A'): + col -= 1 # 跳过字母 'I' + row = int(row_str) - 1 + + flatten_action = (board_size - 1 - row) * board_size + col + return flatten_action + + def render_and_capture_frame(self, mode='only_save_gif'): + self.render(mode=mode) + self.capture_frame() + + def render(self, mode='render_in_ui'): + if not hasattr(self, "frames"): + self.frames = [] + if mode == "board": # print(self._raw_env._go.board) print(self.board) @@ -619,13 +757,13 @@ def render(self, mode='human'): screen_height = 1026 if self.screen is None: - if mode == "human": + if mode in ['only_save_gif', "rgb_array"]: + self.screen = pygame.Surface((screen_width, screen_height)) + elif mode == "render_in_ui": pygame.init() pygame.display.init() self.screen = pygame.display.set_mode((screen_width, screen_height)) - else: - self.screen = pygame.Surface((screen_width, screen_height)) - if mode == "human": + if mode in ["render_in_ui"]: pygame.event.get() size = self.board_size @@ -678,18 +816,25 @@ def render(self, mode='human'): elif board_tmp[i][j] == go_base.WHITE: self.screen.blit(white_stone, ((i * (tile_size) + offset), int(j) * (tile_size) + offset)) - if mode == "human": + if mode == "render_in_ui": pygame.display.update() observation = np.array(pygame.surfarray.pixels3d(self.screen)) return np.transpose(observation, axes=(1, 0, 2)) if mode == "rgb_array" else None - # def observation_space(self): - # return self.observation_spaces - # - # def action_space(self): - # return self._action_space + def capture_frame(self): + if not hasattr(self, "frames"): + self.frames = [] + + frame = np.array(pygame.surfarray.array3d(self.screen)) + # Transpose the frame to fix the rotation issue + fixed_frame = np.transpose(frame, axes=(1, 0, 2)) + self.frames.append(fixed_frame) + + def save_gif(self, output_file, duration=20): + imageio.mimsave(output_file, self.frames, format="GIF", duration=duration) + print("Gif saved to {}".format(output_file)) def _check_bounds(self, c): return 0 <= c[0] < self.board_size and 0 <= c[1] < self.board_size diff --git a/zoo/board_games/go/envs/katago_play_for_lightzero.py b/zoo/board_games/go/envs/katago_play_for_lightzero.py deleted file mode 100644 index 7d400e4ad..000000000 --- a/zoo/board_games/go/envs/katago_play_for_lightzero.py +++ /dev/null @@ -1,931 +0,0 @@ -"""Adapted from https://github.com/lightvector/KataGo/blob/master/python/play.py""" - -# !/usr/bin/python3 -import os -import sys - -# 将 Katago 项目的路径添加到 sys.path 中 -sys.path.append(os.path.abspath('/Users/puyuan/code/KataGo/')) -sys.path.append(os.path.abspath('/Users/puyuan/code/KataGo/python')) - -import argparse -import math -import re -import logging -import colorsys -import numpy as np - -import torch -import torch.nn - -from board import Board -from features import Features -from model_pytorch import EXTRA_SCORE_DISTR_RADIUS -from load_model import load_model - -import sys - -description = """ -Play go with a trained neural net! -Implements a basic GTP engine that uses the neural net directly to play moves. -""" - -parser = argparse.ArgumentParser(description=description) -parser.add_argument('-checkpoint', help='Checkpoint to test', required=False) -parser.add_argument('-use-swa', help='Use SWA model', action="store_true", required=False) - -args = vars(parser.parse_args()) - -# TODO(pu) -# download form https://media.katagotraining.org/uploaded/networks/zips/kata1/kata1-b18c384nbt-s6582191360-d3422816034.zip -# unzip to /Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034 -args['checkpoint'] = "/Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt" -# print(args) - -checkpoint_file = args["checkpoint"] -use_swa = args["use_swa"] - -BOARD_SIZE = 6 -# BOARD_SIZE = 9 - -# Hardcoded max board size -pos_len = 19 - -# Model ---------------------------------------------------------------- - -logging.root.handlers = [] -logging.basicConfig( - level=logging.INFO, - format="%(message)s", - handlers=[ - logging.StreamHandler(stream=sys.stderr), - ], -) -np.set_printoptions(linewidth=150) -torch.set_printoptions(precision=7, sci_mode=False, linewidth=100000, edgeitems=1000, threshold=1000000) - -model, swa_model, _ = load_model(checkpoint_file, use_swa, device="cpu", pos_len=pos_len, verbose=True) -model.eval() -model_config = model.config -if swa_model is not None: - model = swa_model.module - model.eval() - -features = Features(model_config, pos_len) - - -class GameState: - def __init__(self, board_size): - self.board_size = board_size - self.board = Board(size=board_size) - self.moves = [] - self.boards = [self.board.copy()] - - -# Moves ---------------------------------------------------------------- - - -def get_outputs(gs, rules): - with torch.no_grad(): - model.eval() - - bin_input_data = np.zeros(shape=[1] + model.bin_input_shape, dtype=np.float32) - global_input_data = np.zeros(shape=[1] + model.global_input_shape, dtype=np.float32) - pla = gs.board.pla - opp = Board.get_opp(pla) - move_idx = len(gs.moves) - # This function assumes N(HW)C order but we actually use NCHW order, so work with it and revert - bin_input_data = np.transpose(bin_input_data, axes=(0, 2, 3, 1)) - bin_input_data = bin_input_data.reshape([1, pos_len * pos_len, -1]) - features.fill_row_features(gs.board, pla, opp, gs.boards, gs.moves, move_idx, rules, bin_input_data, - global_input_data, idx=0) - bin_input_data = bin_input_data.reshape([1, pos_len, pos_len, -1]) - bin_input_data = np.transpose(bin_input_data, axes=(0, 3, 1, 2)) - - # Currently we don't actually do any symmetries - # symmetry = 0 - # model_outputs = model(apply_symmetry(batch["binaryInputNCHW"],symmetry),batch["globalInputNC"]) - - model_outputs = model( - torch.tensor(bin_input_data, dtype=torch.float32), - torch.tensor(global_input_data, dtype=torch.float32), - ) - outputs = model.postprocess_output(model_outputs) - ( - policy_logits, # N, num_policy_outputs, move - value_logits, # N, {win,loss,noresult} - td_value_logits, # N, {long, mid, short} {win,loss,noresult} - pred_td_score, # N, {long, mid, short} - ownership_pretanh, # N, 1, y, x - pred_scoring, # N, 1, y, x - futurepos_pretanh, # N, 2, y, x - seki_logits, # N, 4, y, x - pred_scoremean, # N - pred_scorestdev, # N - pred_lead, # N - pred_variance_time, # N - pred_shortterm_value_error, # N - pred_shortterm_score_error, # N - scorebelief_logits, # N, 2 * (self.pos_len*self.pos_len + EXTRA_SCORE_DISTR_RADIUS) - ) = (x[0] for x in outputs[0]) # N = 0 - - policy0 = torch.nn.functional.softmax(policy_logits[0, :], dim=0).cpu().numpy() - policy1 = torch.nn.functional.softmax(policy_logits[1, :], dim=0).cpu().numpy() - value = torch.nn.functional.softmax(value_logits, dim=0).cpu().numpy() - td_value = torch.nn.functional.softmax(td_value_logits[0, :], dim=0).cpu().numpy() - td_value2 = torch.nn.functional.softmax(td_value_logits[1, :], dim=0).cpu().numpy() - td_value3 = torch.nn.functional.softmax(td_value_logits[2, :], dim=0).cpu().numpy() - scoremean = pred_scoremean.cpu().item() - td_score = pred_td_score.cpu().numpy() - scorestdev = pred_scorestdev.cpu().item() - lead = pred_lead.cpu().item() - vtime = pred_variance_time.cpu().item() - estv = math.sqrt(pred_shortterm_value_error.cpu().item()) - ests = math.sqrt(pred_shortterm_score_error.cpu().item()) - ownership = torch.tanh(ownership_pretanh).cpu().numpy() - scoring = pred_scoring.cpu().numpy() - futurepos = torch.tanh(futurepos_pretanh).cpu().numpy() - seki_probs = torch.nn.functional.softmax(seki_logits[0:3, :, :], dim=0).cpu().numpy() - seki = seki_probs[1] - seki_probs[2] - seki2 = torch.sigmoid(seki_logits[3, :, :]).cpu().numpy() - scorebelief = torch.nn.functional.softmax(scorebelief_logits, dim=0).cpu().numpy() - - board = gs.board - - moves_and_probs0 = [] - for i in range(len(policy0)): - move = features.tensor_pos_to_loc(i, board) - if i == len(policy0) - 1: - moves_and_probs0.append((Board.PASS_LOC, policy0[i])) - elif board.would_be_legal(board.pla, move): - moves_and_probs0.append((move, policy0[i])) - - moves_and_probs1 = [] - for i in range(len(policy1)): - move = features.tensor_pos_to_loc(i, board) - if i == len(policy1) - 1: - moves_and_probs1.append((Board.PASS_LOC, policy1[i])) - elif board.would_be_legal(board.pla, move): - moves_and_probs1.append((move, policy1[i])) - - ownership_flat = ownership.reshape([features.pos_len * features.pos_len]) - ownership_by_loc = [] - board = gs.board - for y in range(board.size): - for x in range(board.size): - loc = board.loc(x, y) - pos = features.loc_to_tensor_pos(loc, board) - if board.pla == Board.WHITE: - ownership_by_loc.append((loc, ownership_flat[pos])) - else: - ownership_by_loc.append((loc, -ownership_flat[pos])) - - scoring_flat = scoring.reshape([features.pos_len * features.pos_len]) - scoring_by_loc = [] - board = gs.board - for y in range(board.size): - for x in range(board.size): - loc = board.loc(x, y) - pos = features.loc_to_tensor_pos(loc, board) - if board.pla == Board.WHITE: - scoring_by_loc.append((loc, scoring_flat[pos])) - else: - scoring_by_loc.append((loc, -scoring_flat[pos])) - - futurepos0_flat = futurepos[0, :, :].reshape([features.pos_len * features.pos_len]) - futurepos0_by_loc = [] - board = gs.board - for y in range(board.size): - for x in range(board.size): - loc = board.loc(x, y) - pos = features.loc_to_tensor_pos(loc, board) - if board.pla == Board.WHITE: - futurepos0_by_loc.append((loc, futurepos0_flat[pos])) - else: - futurepos0_by_loc.append((loc, -futurepos0_flat[pos])) - - futurepos1_flat = futurepos[1, :, :].reshape([features.pos_len * features.pos_len]) - futurepos1_by_loc = [] - board = gs.board - for y in range(board.size): - for x in range(board.size): - loc = board.loc(x, y) - pos = features.loc_to_tensor_pos(loc, board) - if board.pla == Board.WHITE: - futurepos1_by_loc.append((loc, futurepos1_flat[pos])) - else: - futurepos1_by_loc.append((loc, -futurepos1_flat[pos])) - - seki_flat = seki.reshape([features.pos_len * features.pos_len]) - seki_by_loc = [] - board = gs.board - for y in range(board.size): - for x in range(board.size): - loc = board.loc(x, y) - pos = features.loc_to_tensor_pos(loc, board) - if board.pla == Board.WHITE: - seki_by_loc.append((loc, seki_flat[pos])) - else: - seki_by_loc.append((loc, -seki_flat[pos])) - - seki_flat2 = seki2.reshape([features.pos_len * features.pos_len]) - seki_by_loc2 = [] - board = gs.board - for y in range(board.size): - for x in range(board.size): - loc = board.loc(x, y) - pos = features.loc_to_tensor_pos(loc, board) - seki_by_loc2.append((loc, seki_flat2[pos])) - - moves_and_probs = sorted(moves_and_probs0, key=lambda moveandprob: moveandprob[1], reverse=True) - # Generate a random number biased small and then find the appropriate move to make - # Interpolate from moving uniformly to choosing from the triangular distribution - alpha = 1 - beta = 1 + math.sqrt(max(0, len(gs.moves) - 20)) - r = np.random.beta(alpha, beta) - probsum = 0.0 - i = 0 - genmove_result = Board.PASS_LOC - while True: - (move, prob) = moves_and_probs[i] - probsum += prob - if i >= len(moves_and_probs) - 1 or probsum > r: - genmove_result = move - break - i += 1 - - return { - "policy0": policy0, - "policy1": policy1, - "moves_and_probs0": moves_and_probs0, - "moves_and_probs1": moves_and_probs1, - "value": value, - "td_value": td_value, - "td_value2": td_value2, - "td_value3": td_value3, - "scoremean": scoremean, - "td_score": td_score, - "scorestdev": scorestdev, - "lead": lead, - "vtime": vtime, - "estv": estv, - "ests": ests, - "ownership": ownership, - "ownership_by_loc": ownership_by_loc, - "scoring": scoring, - "scoring_by_loc": scoring_by_loc, - "futurepos": futurepos, - "futurepos0_by_loc": futurepos0_by_loc, - "futurepos1_by_loc": futurepos1_by_loc, - "seki": seki, - "seki_by_loc": seki_by_loc, - "seki2": seki2, - "seki_by_loc2": seki_by_loc2, - "scorebelief": scorebelief, - "genmove_result": genmove_result - } - - -def get_input_feature(gs, rules, feature_idx): - board = gs.board - bin_input_data = np.zeros(shape=[1] + model.bin_input_shape, dtype=np.float32) - global_input_data = np.zeros(shape=[1] + model.global_input_shape, dtype=np.float32) - pla = board.pla - opp = Board.get_opp(pla) - move_idx = len(gs.moves) - features.fill_row_features(board, pla, opp, gs.boards, gs.moves, move_idx, rules, bin_input_data, global_input_data, - idx=0) - - locs_and_values = [] - for y in range(board.size): - for x in range(board.size): - loc = board.loc(x, y) - pos = features.loc_to_tensor_pos(loc, board) - locs_and_values.append((loc, bin_input_data[0, pos, feature_idx])) - return locs_and_values - - -def get_pass_alive(board, rules): - pla = board.pla - opp = Board.get_opp(pla) - area = [-1 for i in range(board.arrsize)] - nonPassAliveStones = False - safeBigTerritories = True - unsafeBigTerritories = False - board.calculateArea(area, nonPassAliveStones, safeBigTerritories, unsafeBigTerritories, - rules["multiStoneSuicideLegal"]) - - locs_and_values = [] - for y in range(board.size): - for x in range(board.size): - loc = board.loc(x, y) - locs_and_values.append((loc, area[loc])) - return locs_and_values - - -def get_gfx_commands_for_heatmap(locs_and_values, board, normalization_div, is_percent, value_and_score_from=None, - hotcold=False): - gfx_commands = [] - divisor = 1.0 - if normalization_div == "max": - max_abs_value = max(abs(value) for (loc, value) in locs_and_values) - divisor = max(0.0000000001, max_abs_value) # avoid divide by zero - elif normalization_div is not None: - divisor = normalization_div - - # Caps value at 1.0, using an asymptotic curve - def loose_cap(x): - def transformed_softplus(x): - return -math.log(math.exp(-(x - 1.0) * 8.0) + 1.0) / 8.0 + 1.0 - - base = transformed_softplus(0.0) - return (transformed_softplus(x) - base) / (1.0 - base) - - # Softly curves a value so that it ramps up faster than linear in that range - def soft_curve(x, x0, x1): - p = (x - x0) / (x1 - x0) - - def curve(p): - return math.sqrt(p + 0.16) - 0.4 - - p = curve(p) / curve(1.0) - return x0 + p * (x1 - x0) - - if hotcold: - for (loc, value) in locs_and_values: - if loc != Board.PASS_LOC: - value = value / divisor - - if value < 0: - value = -loose_cap(-value) - else: - value = loose_cap(value) - - interpoints = [ - (-1.00, (0, 0, 0)), - (-0.85, (15, 0, 50)), - (-0.60, (60, 0, 160)), - (-0.35, (0, 0, 255)), - (-0.15, (0, 100, 255)), - (0.00, (115, 115, 115)), - (0.15, (250, 45, 40)), - (0.25, (255, 55, 0)), - (0.60, (255, 255, 20)), - (0.85, (255, 255, 128)), - (1.00, (255, 255, 255)), - ] - - def lerp(p, y0, y1): - return y0 + p * (y1 - y0) - - i = 0 - while i < len(interpoints): - if value <= interpoints[i][0]: - break - i += 1 - i -= 1 - - if i < 0: - (r, g, b) = interpoints[0][1] - if i >= len(interpoints) - 1: - (r, g, b) = interpoints[len(interpoints) - 1][1] - - p = (value - interpoints[i][0]) / (interpoints[i + 1][0] - interpoints[i][0]) - - (r0, g0, b0) = interpoints[i][1] - (r1, g1, b1) = interpoints[i + 1][1] - r = lerp(p, r0, r1) - g = lerp(p, g0, g1) - b = lerp(p, b0, b1) - - r = ("%02x" % int(r)) - g = ("%02x" % int(g)) - b = ("%02x" % int(b)) - gfx_commands.append("COLOR #%s%s%s %s" % (r, g, b, str_coord(loc, board))) - - else: - for (loc, value) in locs_and_values: - if loc != Board.PASS_LOC: - value = value / divisor - if value < 0: - value = -value - huestart = 0.50 - huestop = 0.86 - else: - huestart = -0.02 - huestop = 0.38 - - value = loose_cap(value) - - def lerp(p, x0, x1, y0, y1): - return y0 + (y1 - y0) * (p - x0) / (x1 - x0) - - if value <= 0.03: - hue = huestart - lightness = 0.00 + 0.50 * (value / 0.03) - saturation = value / 0.03 - (r, g, b) = colorsys.hls_to_rgb((hue + 1) % 1, lightness, saturation) - elif value <= 0.60: - hue = lerp(value, 0.03, 0.60, huestart, huestop) - val = 1.0 - saturation = 1.0 - (r, g, b) = colorsys.hsv_to_rgb((hue + 1) % 1, val, saturation) - else: - hue = huestop - lightness = lerp(value, 0.60, 1.00, 0.5, 0.95) - saturation = 1.0 - (r, g, b) = colorsys.hls_to_rgb((hue + 1) % 1, lightness, saturation) - - r = ("%02x" % int(r * 255)) - g = ("%02x" % int(g * 255)) - b = ("%02x" % int(b * 255)) - gfx_commands.append("COLOR #%s%s%s %s" % (r, g, b, str_coord(loc, board))) - - locs_and_values = sorted(locs_and_values, key=lambda loc_and_value: loc_and_value[1]) - locs_and_values_rev = sorted(locs_and_values, key=lambda loc_and_value: loc_and_value[1], reverse=True) - texts = [] - texts_rev = [] - texts_value = [] - maxlen_per_side = 1000 - if len(locs_and_values) > 0 and locs_and_values[0][1] < 0: - maxlen_per_side = 500 - - for i in range(min(len(locs_and_values), maxlen_per_side)): - (loc, value) = locs_and_values[i] - if is_percent: - texts.append("%s %4.1f%%" % (str_coord(loc, board), value * 100)) - else: - texts.append("%s %.3f" % (str_coord(loc, board), value)) - texts.reverse() - - for i in range(min(len(locs_and_values_rev), maxlen_per_side)): - (loc, value) = locs_and_values_rev[i] - if is_percent: - texts_rev.append("%s %4.1f%%" % (str_coord(loc, board), value * 100)) - else: - texts_rev.append("%s %.3f" % (str_coord(loc, board), value)) - - if value_and_score_from is not None: - value = value_and_score_from["value"] - score = value_and_score_from["scoremean"] - lead = value_and_score_from["lead"] - vtime = value_and_score_from["vtime"] - texts_value.append("wv %.2fc nr %.2f%% ws %.1f wl %.1f vt %.1f" % ( - 100 * (value[0] - value[1] if board.pla == Board.WHITE else value[1] - value[0]), - 100 * value[2], - (score if board.pla == Board.WHITE else -score), - (lead if board.pla == Board.WHITE else -lead), - vtime - )) - - gfx_commands.append("TEXT " + ", ".join(texts_value + texts_rev + texts)) - return gfx_commands - - -def print_scorebelief(gs, outputs): - board = gs.board - scorebelief = outputs["scorebelief"] - lead = outputs["lead"] - scoremean = outputs["scoremean"] - scorestdev = outputs["scorestdev"] - - scorebelief = list(scorebelief) - # Flip so that it's in perspective of the player playing - if board.pla != Board.WHITE: - scorebelief.reverse() - scoremean = -scoremean - lead = -lead - - scoredistrmid = pos_len * pos_len + EXTRA_SCORE_DISTR_RADIUS - ret = "" - ret += "TEXT " - ret += "ScoreBelief: \n" - for i in range(17, -1, -1): - ret += "TEXT " - ret += "%+6.1f" % (-(i * 20 + 0.5)) - for j in range(20): - idx = scoredistrmid - (i * 20 + j) - 1 - ret += " %4.0f" % (scorebelief[idx] * 10000) - ret += "\n" - for i in range(18): - ret += "TEXT " - ret += "%+6.1f" % ((i * 20 + 0.5)) - for j in range(20): - idx = scoredistrmid + (i * 20 + j) - ret += " %4.0f" % (scorebelief[idx] * 10000) - ret += "\n" - - beliefscore = 0 - beliefscoresq = 0 - beliefwin = 0 - belieftotal = 0 - for idx in range(scoredistrmid * 2): - score = idx - scoredistrmid + 0.5 - if score > 0: - beliefwin += scorebelief[idx] - else: - beliefwin -= scorebelief[idx] - belieftotal += scorebelief[idx] - beliefscore += score * scorebelief[idx] - beliefscoresq += score * score * scorebelief[idx] - - beliefscoremean = beliefscore / belieftotal - beliefscoremeansq = beliefscoresq / belieftotal - beliefscorevar = max(0, beliefscoremeansq - beliefscoremean * beliefscoremean) - beliefscorestdev = math.sqrt(beliefscorevar) - - ret += "TEXT BeliefWin: %.2fc\n" % (100 * beliefwin / belieftotal) - ret += "TEXT BeliefScoreMean: %.2f\n" % (beliefscoremean) - ret += "TEXT BeliefScoreStdev: %.2f\n" % (beliefscorestdev) - ret += "TEXT Lead: %.3f\n" % (lead) - ret += "TEXT ScoreMean: %.3f\n" % (scoremean) - ret += "TEXT ScoreStdev: %.3f\n" % (scorestdev) - ret += "TEXT Value: %s\n" % str(["%.3f" % x for x in outputs["value"]]) - ret += "TEXT TDValue: %s\n" % str(["%.3f" % x for x in outputs["td_value"]]) - ret += "TEXT TDValue2: %s\n" % str(["%.3f" % x for x in outputs["td_value2"]]) - ret += "TEXT TDValue3: %s\n" % str(["%.3f" % x for x in outputs["td_value3"]]) - ret += "TEXT TDScore: %s\n" % str(["%.3f" % x for x in outputs["td_score"]]) - ret += "TEXT Estv: %s\n" % str(outputs["estv"]) - ret += "TEXT Ests: %s\n" % str(outputs["ests"]) - ret += "TEXT Vtime: %s\n" % str(outputs["vtime"]) - return ret - - -# Basic parsing -------------------------------------------------------- -colstr = 'ABCDEFGHJKLMNOPQRST' - - -def parse_coord(s, board): - """ Covert GTP-coord to (row, col) pair.""" - if s == 'pass': - return Board.PASS_LOC - return board.loc(colstr.index(s[0].upper()), board.size - int(s[1:])) - - -def str_coord(loc, board): - """ Convert katago Flattened Coordinate to GTP-coord.""" - # self.arrsize = (board_size + 1) * (board_size + 2) + 1 - # xxxxxxxxxx - # .........x - # .........x - # .........x - # .........x - # .........x - # .........x - # .........x - # .........x - # .........x - # xxxxxxxxxx - - if loc == Board.PASS_LOC: - return 'pass' - x = board.loc_x(loc) - y = board.loc_y(loc) - return '%c%d' % (colstr[x], board.size - y) - - -def katago_flatten_to_lz_flatten(loc, board): - """ Convert katago Flattened Coordinate to lz Flattened Coordinate.""" - # self.arrsize = (board_size + 1) * (board_size + 2) + 1 - # xxxxxxxxxx - # .........x - # .........x - # .........x - # .........x - # .........x - # .........x - # .........x - # .........x - # .........x - # xxxxxxxxxx - - if loc == Board.PASS_LOC: - # pass - return board.size * board.size - x = board.loc_x(loc) # left_to_right 0,1,2,...,board.size-1 - y = board.loc_y(loc) # upper_to_bottom 0,1,2,...,board.size-1 - return y * board.size + x - # 11 -> (0,0) -> 0 - # 21 -> (0,1) -> 9 - - -# GTP Implementation ----------------------------------------------------- - -# Adapted from https://github.com/pasky/michi/blob/master/michi.py, which is distributed under MIT license -# https://opensource.org/licenses/MIT - -known_commands = [ - 'boardsize', - 'clear_board', - 'showboard', - 'komi', - 'play', - 'genmove', - 'quit', - 'name', - 'version', - 'known_command', - 'list_commands', - 'protocol_version', - 'gogui-analyze_commands', - 'setrule', - 'policy', - 'policy1', - 'logpolicy', - 'ownership', - 'scoring', - 'futurepos0', - 'futurepos1', - 'seki', - 'seki2', - 'scorebelief', - 'passalive', -] -known_analyze_commands = [ - 'gfx/Policy/policy', - 'gfx/Policy1/policy1', - 'gfx/LogPolicy/logpolicy', - 'gfx/Ownership/ownership', - 'gfx/Scoring/scoring', - 'gfx/FuturePos0/futurepos0', - 'gfx/FuturePos1/futurepos1', - 'gfx/Seki/seki', - 'gfx/Seki2/seki2', - 'gfx/ScoreBelief/scorebelief', - 'gfx/PassAlive/passalive', -] - -board_size = BOARD_SIZE - -gs = GameState(board_size) - -rules = { - "koRule": "KO_POSITIONAL", - "scoringRule": "SCORING_AREA", - "taxRule": "TAX_NONE", - # TODO(pu): - "multiStoneSuicideLegal": False, - # "multiStoneSuicideLegal": True, - "hasButton": False, - "encorePhase": 0, - "passWouldEndPhase": False, - "whiteKomi": 7.5, - "asymPowersOfTwo": 0.0, -} - -input_feature_command_lookup = dict() - - -def add_input_feature_visualizations(layer_name, feature_idx, normalization_div): - command_name = layer_name - command_name = command_name.replace("/", ":") - known_commands.append(command_name) - known_analyze_commands.append("gfx/" + command_name + "/" + command_name) - input_feature_command_lookup[command_name] = (feature_idx, normalization_div) - - -for i in range(model.bin_input_shape[1]): - add_input_feature_visualizations("input-" + str(i), i, normalization_div=1) - - -def get_board_matrix_str(matrix, scale, formatstr): - ret = "" - matrix = matrix.reshape([features.pos_len, features.pos_len]) - for y in range(features.pos_len): - for x in range(features.pos_len): - ret += formatstr % (scale * matrix[y, x]) - ret += " " - ret += "\n" - return ret - - -# while True: -def katago_move(game_state, command, to_play=None): - """ - command = ['play', 'b', 'a4'] - command = ['play', 'w', 'a4'] - command = ['genmove', 'w', 'a4'] - command = ['get_katago_action'] - command = ['boardsize', 9] - command = ["showboard"] - - """ - gs = game_state - if re.match('\d+', command[0]): - cmdid = command[0] - command = command[1:] - else: - cmdid = '' - - ret = '' - if command[0] == "showboard": - ret = "\n" + gs.board.to_string().strip() - elif command[0] == "komi": - rules["whiteKomi"] = float(command[1]) - elif command[0] == "play": - pla = (Board.BLACK if command[1] == "B" or command[1] == "b" else Board.WHITE) - loc = parse_coord(command[2], gs.board) - gs.board.play(pla, loc) - gs.moves.append((pla, loc)) - gs.boards.append(gs.board.copy()) - return gs - elif command[0] == "genmove": - outputs = get_outputs(gs, rules) - loc = outputs["genmove_result"] - pla = gs.board.pla - - if len(command) > 1: - pla = (Board.BLACK if command[1] == "B" or command[1] == "b" else Board.WHITE) - gs.board.play(pla, loc) - gs.moves.append((pla, loc)) - gs.boards.append(gs.board.copy()) - ret = str_coord(loc, gs.board) - - elif command[0] == "get_katago_action": - # NOTE: here bot action may be illegal action - outputs = get_outputs(gs, rules) - if to_play == 1: - moves_and_probs0 = outputs["moves_and_probs0"] - moves_and_probs = sorted(moves_and_probs0, key=lambda moveandprob: moveandprob[1], reverse=True) - katago_flatten_action = moves_and_probs[0][0] - elif to_play == 2: - moves_and_probs1 = outputs["moves_and_probs1"] - moves_and_probs = sorted(moves_and_probs1, key=lambda moveandprob: moveandprob[1], reverse=True) - katago_flatten_action = moves_and_probs[0][0] - # gtp_action = str_coord(katago_flatten_action, gs.board) - lz_flatten_action = katago_flatten_to_lz_flatten(katago_flatten_action, gs.board) - return lz_flatten_action - - elif command[0] == "name": - ret = 'KataGo Raw Neural Net Debug/Test Script' - elif command[0] == "version": - ret = '1.0' - elif command[0] == "list_commands": - ret = '\n'.join(known_commands) - elif command[0] == "known_command": - ret = 'true' if command[1] in known_commands else 'false' - elif command[0] == "gogui-analyze_commands": - ret = '\n'.join(known_analyze_commands) - elif command[0] == "setrule": - ret = "" - if command[1] == "korule": - rules["koRule"] = command[2].upper() - elif command[1] == "scoringrule": - rules["scoringRule"] = command[2].upper() - elif command[1] == "taxrule": - rules["taxRule"] = command[2].upper() - elif command[1] == "multistonesuicidelegal": - rules["multiStoneSuicideLegal"] = (command[2].lower() == "true") - elif command[1] == "hasbutton": - rules["hasButton"] = (command[2].lower() == "true") - elif command[1] == "encorephase": - rules["encorePhase"] = int(command[2]) - elif command[1] == "passwouldendphase": - rules["passWouldEndPhase"] = (command[2].lower() == "true") - elif command[1] == "whitekomi" or command[1] == "komi": - rules["whiteKomi"] = float(command[2]) - elif command[1] == "asym": - rules["asymPowersOfTwo"] = float(command[2]) - else: - ret = "Unknown rules setting" - elif command[0] == "policy": - outputs = get_outputs(gs, rules) - gfx_commands = get_gfx_commands_for_heatmap(outputs["moves_and_probs0"], gs.board, normalization_div=None, - is_percent=True, value_and_score_from=outputs) - ret = "\n".join(gfx_commands) - elif command[0] == "policy1": - outputs = get_outputs(gs, rules) - gfx_commands = get_gfx_commands_for_heatmap(outputs["moves_and_probs1"], gs.board, normalization_div=None, - is_percent=True, value_and_score_from=outputs) - ret = "\n".join(gfx_commands) - elif command[0] == "logpolicy": - outputs = get_outputs(gs, rules) - moves_and_logprobs = [(move, max(0.0, 4.9 + math.log10(prob))) for (move, prob) in outputs["moves_and_probs0"]] - gfx_commands = get_gfx_commands_for_heatmap(moves_and_logprobs, gs.board, normalization_div=6, is_percent=False, - value_and_score_from=outputs) - ret = "\n".join(gfx_commands) - elif command[0] == "ownership": - outputs = get_outputs(gs, rules) - gfx_commands = get_gfx_commands_for_heatmap(outputs["ownership_by_loc"], gs.board, normalization_div=None, - is_percent=True, value_and_score_from=None, hotcold=True) - ret = "\n".join(gfx_commands) - elif command[0] == "scoring": - outputs = get_outputs(gs, rules) - gfx_commands = get_gfx_commands_for_heatmap(outputs["scoring_by_loc"], gs.board, normalization_div=None, - is_percent=True, value_and_score_from=None, hotcold=True) - ret = "\n".join(gfx_commands) - elif command[0] == "futurepos0": - outputs = get_outputs(gs, rules) - gfx_commands = get_gfx_commands_for_heatmap(outputs["futurepos0_by_loc"], gs.board, normalization_div=None, - is_percent=True, value_and_score_from=None, hotcold=True) - ret = "\n".join(gfx_commands) - elif command[0] == "futurepos1": - outputs = get_outputs(gs, rules) - gfx_commands = get_gfx_commands_for_heatmap(outputs["futurepos1_by_loc"], gs.board, normalization_div=None, - is_percent=True, value_and_score_from=None, hotcold=True) - ret = "\n".join(gfx_commands) - elif command[0] == "seki": - outputs = get_outputs(gs, rules) - gfx_commands = get_gfx_commands_for_heatmap(outputs["seki_by_loc"], gs.board, normalization_div=None, - is_percent=True, value_and_score_from=None) - ret = "\n".join(gfx_commands) - elif command[0] == "seki2": - outputs = get_outputs(gs, rules) - gfx_commands = get_gfx_commands_for_heatmap(outputs["seki_by_loc2"], gs.board, normalization_div=None, - is_percent=True, value_and_score_from=None) - ret = "\n".join(gfx_commands) - - elif command[0] == "policy_raw": - outputs = get_outputs(gs, rules) - ret = "\n" - - policysum = 0.0 - for y in range(gs.board.size): - for x in range(gs.board.size): - loc = gs.board.loc(x, y) - pos = features.loc_to_tensor_pos(loc, gs.board) - gs.board.would_be_legal(gs.board.pla, loc) - policysum += outputs["policy0"][pos] - loc = Board.PASS_LOC - pos = features.loc_to_tensor_pos(loc, gs.board) - policysum += outputs["policy0"][pos] - - for y in range(gs.board.size): - for x in range(gs.board.size): - loc = gs.board.loc(x, y) - pos = features.loc_to_tensor_pos(loc, gs.board) - if gs.board.would_be_legal(gs.board.pla, loc): - ret += "%6.3f" % (100.0 * outputs["policy0"][pos] / policysum) - else: - ret += " - " - ret += " " - ret += "\n" - loc = Board.PASS_LOC - pos = features.loc_to_tensor_pos(loc, gs.board) - ret += "Pass: %6.3f" % (100.0 * outputs["policy0"][pos] / policysum) - - elif command[0] == "policy1_raw": - outputs = get_outputs(gs, rules) - ret = "\n" - - for y in range(gs.board.size): - for x in range(gs.board.size): - loc = gs.board.loc(x, y) - pos = features.loc_to_tensor_pos(loc, gs.board) - if gs.board.would_be_legal(gs.board.pla, loc): - ret += "%6.3f" % (100.0 * outputs["policy1"][pos]) - else: - ret += " - " - ret += " " - ret += "\n" - loc = Board.PASS_LOC - pos = features.loc_to_tensor_pos(loc, gs.board) - ret += "Pass: %6.3f" % (100.0 * outputs["policy1"][pos]) - - elif command[0] == "ownership_raw": - outputs = get_outputs(gs, rules) - ret = get_board_matrix_str(outputs["ownership"], 100.0, "%+7.3f") - elif command[0] == "scoring_raw": - outputs = get_outputs(gs, rules) - ret = get_board_matrix_str(outputs["scoring"], 100.0, "%+7.3f") - elif command[0] == "futurepos0_raw": - outputs = get_outputs(gs, rules) - ret = get_board_matrix_str(outputs["futurepos"][0], 100.0, "%+7.3f") - elif command[0] == "futurepos1_raw": - outputs = get_outputs(gs, rules) - ret = get_board_matrix_str(outputs["futurepos"][1], 100.0, "%+7.3f") - elif command[0] == "seki_raw": - outputs = get_outputs(gs, rules) - ret = get_board_matrix_str(outputs["seki"], 100.0, "%+7.3f") - elif command[0] == "seki2_raw": - outputs = get_outputs(gs, rules) - ret = get_board_matrix_str(outputs["seki2"], 100.0, "%+7.3f") - - elif command[0] in input_feature_command_lookup: - (feature_idx, normalization_div) = input_feature_command_lookup[command[0]] - locs_and_values = get_input_feature(gs, rules, feature_idx) - gfx_commands = get_gfx_commands_for_heatmap(locs_and_values, gs.board, normalization_div, is_percent=False) - ret = "\n".join(gfx_commands) - - elif command[0] == "passalive": - locs_and_values = get_pass_alive(gs.board, rules) - gfx_commands = get_gfx_commands_for_heatmap(locs_and_values, gs.board, normalization_div=None, is_percent=False) - ret = "\n".join(gfx_commands) - - elif command[0] == "scorebelief": - outputs = get_outputs(gs, rules) - ret = print_scorebelief(gs, outputs) - - elif command[0] == "protocol_version": - ret = '2' - elif command[0] == "quit": - print('=%s \n\n' % (cmdid,), end='') - else: - print('Warning: Ignoring unknown command - %s' % (line,), file=sys.stderr) - ret = None - - if ret is not None: - print('=%s %s\n\n' % (cmdid, ret,), end='') - else: - print('?%s ???\n\n' % (cmdid,), end='') - sys.stdout.flush() diff --git a/zoo/board_games/go/envs/katago_policy.py b/zoo/board_games/go/envs/katago_policy.py new file mode 100644 index 000000000..80af69941 --- /dev/null +++ b/zoo/board_games/go/envs/katago_policy.py @@ -0,0 +1,950 @@ +"""Adapted from https://github.com/lightvector/KataGo/blob/master/python/play.py""" + +# !/usr/bin/python3 +import os +import sys + +# 将 Katago 项目的路径添加到 sys.path 中 +sys.path.append(os.path.abspath('/Users/puyuan/code/KataGo/')) +sys.path.append(os.path.abspath('/Users/puyuan/code/KataGo/python')) + +import argparse +import math +import re +import logging +import colorsys +import numpy as np + +import torch +import torch.nn + +from board import Board +from features import Features +from model_pytorch import EXTRA_SCORE_DISTR_RADIUS +from load_model import load_model + +import sys + +description = """ +Play go with a trained neural net! +Implements a basic GTP engine that uses the neural net directly to play moves. +""" +# if __name__ == "__main__": +# parser = argparse.ArgumentParser(description=description) +# parser.add_argument('-checkpoint', help='Checkpoint to test', required=False) +# parser.add_argument('-use-swa', help='Use SWA model', action="store_true", required=False) +# +# args = vars(parser.parse_args()) + +# Basic parsing -------------------------------------------------------- +colstr = 'ABCDEFGHJKLMNOPQRST' + + +def parse_coord(s, board): + """ Covert GTP-coord to (row, col) pair.""" + if s == 'pass': + return Board.PASS_LOC + return board.loc(colstr.index(s[0].upper()), board.size - int(s[1:])) + + +def str_coord(loc, board): + """ Convert katago Flattened Coordinate to GTP-coord.""" + # self.arrsize = (board_size + 1) * (board_size + 2) + 1 + # xxxxxxxxxx + # .........x + # .........x + # .........x + # .........x + # .........x + # .........x + # .........x + # .........x + # .........x + # xxxxxxxxxx + + if loc == Board.PASS_LOC: + return 'pass' + x = board.loc_x(loc) + y = board.loc_y(loc) + return '%c%d' % (colstr[x], board.size - y) + + +def katago_flatten_to_lz_flatten(loc, board): + """ Convert katago Flattened Coordinate to lz Flattened Coordinate.""" + # self.arrsize = (board_size + 1) * (board_size + 2) + 1 + # xxxxxxxxxx + # .........x + # .........x + # .........x + # .........x + # .........x + # .........x + # .........x + # .........x + # .........x + # xxxxxxxxxx + + if loc == Board.PASS_LOC: + # pass + return board.size * board.size + x = board.loc_x(loc) # left_to_right 0,1,2,...,board.size-1 + y = board.loc_y(loc) # upper_to_bottom 0,1,2,...,board.size-1 + if y * board.size + x <0: + print('debug') + return y * board.size + x + # 11 -> (0,0) -> 0 + # 21 -> (0,1) -> 9 + + +class GameState: + def __init__(self, board_size): + self.board_size = board_size + self.board = Board(size=board_size) + self.moves = [] + self.boards = [self.board.copy()] + + +# Moves ---------------------------------------------------------------- + + +def get_pass_alive(board, rules): + pla = board.pla + opp = Board.get_opp(pla) + area = [-1 for i in range(board.arrsize)] + nonPassAliveStones = False + safeBigTerritories = True + unsafeBigTerritories = False + board.calculateArea(area, nonPassAliveStones, safeBigTerritories, unsafeBigTerritories, + rules["multiStoneSuicideLegal"]) + + locs_and_values = [] + for y in range(board.size): + for x in range(board.size): + loc = board.loc(x, y) + locs_and_values.append((loc, area[loc])) + return locs_and_values + + +def get_gfx_commands_for_heatmap(locs_and_values, board, normalization_div, is_percent, value_and_score_from=None, + hotcold=False): + gfx_commands = [] + divisor = 1.0 + if normalization_div == "max": + max_abs_value = max(abs(value) for (loc, value) in locs_and_values) + divisor = max(0.0000000001, max_abs_value) # avoid divide by zero + elif normalization_div is not None: + divisor = normalization_div + + # Caps value at 1.0, using an asymptotic curve + def loose_cap(x): + def transformed_softplus(x): + return -math.log(math.exp(-(x - 1.0) * 8.0) + 1.0) / 8.0 + 1.0 + + base = transformed_softplus(0.0) + return (transformed_softplus(x) - base) / (1.0 - base) + + # Softly curves a value so that it ramps up faster than linear in that range + def soft_curve(x, x0, x1): + p = (x - x0) / (x1 - x0) + + def curve(p): + return math.sqrt(p + 0.16) - 0.4 + + p = curve(p) / curve(1.0) + return x0 + p * (x1 - x0) + + if hotcold: + for (loc, value) in locs_and_values: + if loc != Board.PASS_LOC: + value = value / divisor + + if value < 0: + value = -loose_cap(-value) + else: + value = loose_cap(value) + + interpoints = [ + (-1.00, (0, 0, 0)), + (-0.85, (15, 0, 50)), + (-0.60, (60, 0, 160)), + (-0.35, (0, 0, 255)), + (-0.15, (0, 100, 255)), + (0.00, (115, 115, 115)), + (0.15, (250, 45, 40)), + (0.25, (255, 55, 0)), + (0.60, (255, 255, 20)), + (0.85, (255, 255, 128)), + (1.00, (255, 255, 255)), + ] + + def lerp(p, y0, y1): + return y0 + p * (y1 - y0) + + i = 0 + while i < len(interpoints): + if value <= interpoints[i][0]: + break + i += 1 + i -= 1 + + if i < 0: + (r, g, b) = interpoints[0][1] + if i >= len(interpoints) - 1: + (r, g, b) = interpoints[len(interpoints) - 1][1] + + p = (value - interpoints[i][0]) / (interpoints[i + 1][0] - interpoints[i][0]) + + (r0, g0, b0) = interpoints[i][1] + (r1, g1, b1) = interpoints[i + 1][1] + r = lerp(p, r0, r1) + g = lerp(p, g0, g1) + b = lerp(p, b0, b1) + + r = ("%02x" % int(r)) + g = ("%02x" % int(g)) + b = ("%02x" % int(b)) + gfx_commands.append("COLOR #%s%s%s %s" % (r, g, b, str_coord(loc, board))) + + else: + for (loc, value) in locs_and_values: + if loc != Board.PASS_LOC: + value = value / divisor + if value < 0: + value = -value + huestart = 0.50 + huestop = 0.86 + else: + huestart = -0.02 + huestop = 0.38 + + value = loose_cap(value) + + def lerp(p, x0, x1, y0, y1): + return y0 + (y1 - y0) * (p - x0) / (x1 - x0) + + if value <= 0.03: + hue = huestart + lightness = 0.00 + 0.50 * (value / 0.03) + saturation = value / 0.03 + (r, g, b) = colorsys.hls_to_rgb((hue + 1) % 1, lightness, saturation) + elif value <= 0.60: + hue = lerp(value, 0.03, 0.60, huestart, huestop) + val = 1.0 + saturation = 1.0 + (r, g, b) = colorsys.hsv_to_rgb((hue + 1) % 1, val, saturation) + else: + hue = huestop + lightness = lerp(value, 0.60, 1.00, 0.5, 0.95) + saturation = 1.0 + (r, g, b) = colorsys.hls_to_rgb((hue + 1) % 1, lightness, saturation) + + r = ("%02x" % int(r * 255)) + g = ("%02x" % int(g * 255)) + b = ("%02x" % int(b * 255)) + gfx_commands.append("COLOR #%s%s%s %s" % (r, g, b, str_coord(loc, board))) + + locs_and_values = sorted(locs_and_values, key=lambda loc_and_value: loc_and_value[1]) + locs_and_values_rev = sorted(locs_and_values, key=lambda loc_and_value: loc_and_value[1], reverse=True) + texts = [] + texts_rev = [] + texts_value = [] + maxlen_per_side = 1000 + if len(locs_and_values) > 0 and locs_and_values[0][1] < 0: + maxlen_per_side = 500 + + for i in range(min(len(locs_and_values), maxlen_per_side)): + (loc, value) = locs_and_values[i] + if is_percent: + texts.append("%s %4.1f%%" % (str_coord(loc, board), value * 100)) + else: + texts.append("%s %.3f" % (str_coord(loc, board), value)) + texts.reverse() + + for i in range(min(len(locs_and_values_rev), maxlen_per_side)): + (loc, value) = locs_and_values_rev[i] + if is_percent: + texts_rev.append("%s %4.1f%%" % (str_coord(loc, board), value * 100)) + else: + texts_rev.append("%s %.3f" % (str_coord(loc, board), value)) + + if value_and_score_from is not None: + value = value_and_score_from["value"] + score = value_and_score_from["scoremean"] + lead = value_and_score_from["lead"] + vtime = value_and_score_from["vtime"] + texts_value.append("wv %.2fc nr %.2f%% ws %.1f wl %.1f vt %.1f" % ( + 100 * (value[0] - value[1] if board.pla == Board.WHITE else value[1] - value[0]), + 100 * value[2], + (score if board.pla == Board.WHITE else -score), + (lead if board.pla == Board.WHITE else -lead), + vtime + )) + + gfx_commands.append("TEXT " + ", ".join(texts_value + texts_rev + texts)) + return gfx_commands + + +# GTP Implementation ----------------------------------------------------- + +# Adapted from https://github.com/pasky/michi/blob/master/michi.py, which is distributed under MIT license +# https://opensource.org/licenses/MIT + +known_commands = [ + 'boardsize', + 'clear_board', + 'showboard', + 'komi', + 'play', + 'genmove', + 'quit', + 'name', + 'version', + 'known_command', + 'list_commands', + 'protocol_version', + 'gogui-analyze_commands', + 'setrule', + 'policy', + 'policy1', + 'logpolicy', + 'ownership', + 'scoring', + 'futurepos0', + 'futurepos1', + 'seki', + 'seki2', + 'scorebelief', + 'passalive', +] +known_analyze_commands = [ + 'gfx/Policy/policy', + 'gfx/Policy1/policy1', + 'gfx/LogPolicy/logpolicy', + 'gfx/Ownership/ownership', + 'gfx/Scoring/scoring', + 'gfx/FuturePos0/futurepos0', + 'gfx/FuturePos1/futurepos1', + 'gfx/Seki/seki', + 'gfx/Seki2/seki2', + 'gfx/ScoreBelief/scorebelief', + 'gfx/PassAlive/passalive', +] + +# board_size = BOARD_SIZE +# +# gs = GameState(board_size) + +rules = { + "koRule": "KO_POSITIONAL", + "scoringRule": "SCORING_AREA", + "taxRule": "TAX_NONE", + # TODO(pu): + "multiStoneSuicideLegal": False, + # "multiStoneSuicideLegal": True, + "hasButton": False, + "encorePhase": 0, + "passWouldEndPhase": False, + "whiteKomi": 7.5, + "asymPowersOfTwo": 0.0, +} + +input_feature_command_lookup = dict() + + +class KatagoPolicy(): + + def __init__(self, checkpoint_path="/Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", + board_size=9, ignore_pass_if_have_other_legal_actions=False): + self.load_katago_model(checkpoint_path, board_size) + for i in range(self.model.bin_input_shape[1]): + self.add_input_feature_visualizations("input-" + str(i), i, normalization_div=1) + + self.ignore_pass_if_have_other_legal_actions= ignore_pass_if_have_other_legal_actions + def load_katago_model(self, + checkpoint_path="/Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", + board_size=9): + args = {} + args["use_swa"] = False + + # TODO(pu) + # download form https://media.katagotraining.org/uploaded/networks/zips/kata1/kata1-b18c384nbt-s6582191360-d3422816034.zip + # unzip to /Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034 + args['checkpoint'] = checkpoint_path + + checkpoint_file = args["checkpoint"] + use_swa = args["use_swa"] + + BOARD_SIZE = board_size + + # print(args) + + # Hardcoded max board size + self.pos_len = 19 + + # Model ---------------------------------------------------------------- + + logging.root.handlers = [] + logging.basicConfig( + level=logging.INFO, + format="%(message)s", + handlers=[ + logging.StreamHandler(stream=sys.stderr), + ], + ) + np.set_printoptions(linewidth=150) + torch.set_printoptions(precision=7, sci_mode=False, linewidth=100000, edgeitems=1000, threshold=1000000) + + model, swa_model, _ = load_model(checkpoint_file, use_swa, device="cpu", pos_len=self.pos_len, verbose=True) + model.eval() + model_config = model.config + if swa_model is not None: + model = swa_model.module + model.eval() + + self.features = Features(model_config, self.pos_len) + self.model = model + + def get_outputs(self, gs, rules): + with torch.no_grad(): + self.model.eval() + + bin_input_data = np.zeros(shape=[1] + self.model.bin_input_shape, dtype=np.float32) + global_input_data = np.zeros(shape=[1] + self.model.global_input_shape, dtype=np.float32) + pla = gs.board.pla + opp = Board.get_opp(pla) + move_idx = len(gs.moves) + # This function assumes N(HW)C order but we actually use NCHW order, so work with it and revert + bin_input_data = np.transpose(bin_input_data, axes=(0, 2, 3, 1)) + bin_input_data = bin_input_data.reshape([1, self.pos_len * self.pos_len, -1]) + self.features.fill_row_features(gs.board, pla, opp, gs.boards, gs.moves, move_idx, rules, bin_input_data, + global_input_data, idx=0) + bin_input_data = bin_input_data.reshape([1, self.pos_len, self.pos_len, -1]) + bin_input_data = np.transpose(bin_input_data, axes=(0, 3, 1, 2)) + + # Currently we don't actually do any symmetries + # symmetry = 0 + # self.model_outputs = self.model(apply_symmetry(batch["binaryInputNCHW"],symmetry),batch["globalInputNC"]) + + model_outputs = self.model( + torch.tensor(bin_input_data, dtype=torch.float32), + torch.tensor(global_input_data, dtype=torch.float32), + ) + outputs = self.model.postprocess_output(model_outputs) + ( + policy_logits, # N, num_policy_outputs, move + value_logits, # N, {win,loss,noresult} + td_value_logits, # N, {long, mid, short} {win,loss,noresult} + pred_td_score, # N, {long, mid, short} + ownership_pretanh, # N, 1, y, x + pred_scoring, # N, 1, y, x + futurepos_pretanh, # N, 2, y, x + seki_logits, # N, 4, y, x + pred_scoremean, # N + pred_scorestdev, # N + pred_lead, # N + pred_variance_time, # N + pred_shortterm_value_error, # N + pred_shortterm_score_error, # N + scorebelief_logits, # N, 2 * (self.pos_len*self.pos_len + EXTRA_SCORE_DISTR_RADIUS) + ) = (x[0] for x in outputs[0]) # N = 0 + + policy0 = torch.nn.functional.softmax(policy_logits[0, :], dim=0).cpu().numpy() + policy1 = torch.nn.functional.softmax(policy_logits[1, :], dim=0).cpu().numpy() + value = torch.nn.functional.softmax(value_logits, dim=0).cpu().numpy() + td_value = torch.nn.functional.softmax(td_value_logits[0, :], dim=0).cpu().numpy() + td_value2 = torch.nn.functional.softmax(td_value_logits[1, :], dim=0).cpu().numpy() + td_value3 = torch.nn.functional.softmax(td_value_logits[2, :], dim=0).cpu().numpy() + scoremean = pred_scoremean.cpu().item() + td_score = pred_td_score.cpu().numpy() + scorestdev = pred_scorestdev.cpu().item() + lead = pred_lead.cpu().item() + vtime = pred_variance_time.cpu().item() + estv = math.sqrt(pred_shortterm_value_error.cpu().item()) + ests = math.sqrt(pred_shortterm_score_error.cpu().item()) + ownership = torch.tanh(ownership_pretanh).cpu().numpy() + scoring = pred_scoring.cpu().numpy() + futurepos = torch.tanh(futurepos_pretanh).cpu().numpy() + seki_probs = torch.nn.functional.softmax(seki_logits[0:3, :, :], dim=0).cpu().numpy() + seki = seki_probs[1] - seki_probs[2] + seki2 = torch.sigmoid(seki_logits[3, :, :]).cpu().numpy() + scorebelief = torch.nn.functional.softmax(scorebelief_logits, dim=0).cpu().numpy() + + board = gs.board + + moves_and_probs0 = [] + for i in range(len(policy0)): + move = self.features.tensor_pos_to_loc(i, board) + if i == len(policy0) - 1: + moves_and_probs0.append((Board.PASS_LOC, policy0[i])) + elif board.would_be_legal(board.pla, move): + moves_and_probs0.append((move, policy0[i])) + + moves_and_probs1 = [] + for i in range(len(policy1)): + move = self.features.tensor_pos_to_loc(i, board) + if i == len(policy1) - 1: + moves_and_probs1.append((Board.PASS_LOC, policy1[i])) + elif board.would_be_legal(board.pla, move): + moves_and_probs1.append((move, policy1[i])) + + ownership_flat = ownership.reshape([self.features.pos_len * self.features.pos_len]) + ownership_by_loc = [] + board = gs.board + for y in range(board.size): + for x in range(board.size): + loc = board.loc(x, y) + pos = self.features.loc_to_tensor_pos(loc, board) + if board.pla == Board.WHITE: + ownership_by_loc.append((loc, ownership_flat[pos])) + else: + ownership_by_loc.append((loc, -ownership_flat[pos])) + + scoring_flat = scoring.reshape([self.features.pos_len * self.features.pos_len]) + scoring_by_loc = [] + board = gs.board + for y in range(board.size): + for x in range(board.size): + loc = board.loc(x, y) + pos = self.features.loc_to_tensor_pos(loc, board) + if board.pla == Board.WHITE: + scoring_by_loc.append((loc, scoring_flat[pos])) + else: + scoring_by_loc.append((loc, -scoring_flat[pos])) + + futurepos0_flat = futurepos[0, :, :].reshape([self.features.pos_len * self.features.pos_len]) + futurepos0_by_loc = [] + board = gs.board + for y in range(board.size): + for x in range(board.size): + loc = board.loc(x, y) + pos = self.features.loc_to_tensor_pos(loc, board) + if board.pla == Board.WHITE: + futurepos0_by_loc.append((loc, futurepos0_flat[pos])) + else: + futurepos0_by_loc.append((loc, -futurepos0_flat[pos])) + + futurepos1_flat = futurepos[1, :, :].reshape([self.features.pos_len * self.features.pos_len]) + futurepos1_by_loc = [] + board = gs.board + for y in range(board.size): + for x in range(board.size): + loc = board.loc(x, y) + pos = self.features.loc_to_tensor_pos(loc, board) + if board.pla == Board.WHITE: + futurepos1_by_loc.append((loc, futurepos1_flat[pos])) + else: + futurepos1_by_loc.append((loc, -futurepos1_flat[pos])) + + seki_flat = seki.reshape([self.features.pos_len * self.features.pos_len]) + seki_by_loc = [] + board = gs.board + for y in range(board.size): + for x in range(board.size): + loc = board.loc(x, y) + pos = self.features.loc_to_tensor_pos(loc, board) + if board.pla == Board.WHITE: + seki_by_loc.append((loc, seki_flat[pos])) + else: + seki_by_loc.append((loc, -seki_flat[pos])) + + seki_flat2 = seki2.reshape([self.features.pos_len * self.features.pos_len]) + seki_by_loc2 = [] + board = gs.board + for y in range(board.size): + for x in range(board.size): + loc = board.loc(x, y) + pos = self.features.loc_to_tensor_pos(loc, board) + seki_by_loc2.append((loc, seki_flat2[pos])) + + moves_and_probs = sorted(moves_and_probs0, key=lambda moveandprob: moveandprob[1], reverse=True) + # Generate a random number biased small and then find the appropriate move to make + # Interpolate from moving uniformly to choosing from the triangular distribution + alpha = 1 + beta = 1 + math.sqrt(max(0, len(gs.moves) - 20)) + r = np.random.beta(alpha, beta) + probsum = 0.0 + i = 0 + genmove_result = Board.PASS_LOC + while True: + (move, prob) = moves_and_probs[i] + probsum += prob + if i >= len(moves_and_probs) - 1 or probsum > r: + genmove_result = move + break + i += 1 + + return { + "policy0": policy0, + "policy1": policy1, + "moves_and_probs0": moves_and_probs0, + "moves_and_probs1": moves_and_probs1, + "value": value, + "td_value": td_value, + "td_value2": td_value2, + "td_value3": td_value3, + "scoremean": scoremean, + "td_score": td_score, + "scorestdev": scorestdev, + "lead": lead, + "vtime": vtime, + "estv": estv, + "ests": ests, + "ownership": ownership, + "ownership_by_loc": ownership_by_loc, + "scoring": scoring, + "scoring_by_loc": scoring_by_loc, + "futurepos": futurepos, + "futurepos0_by_loc": futurepos0_by_loc, + "futurepos1_by_loc": futurepos1_by_loc, + "seki": seki, + "seki_by_loc": seki_by_loc, + "seki2": seki2, + "seki_by_loc2": seki_by_loc2, + "scorebelief": scorebelief, + "genmove_result": genmove_result + } + + def get_input_feature(self, gs, rules, feature_idx): + board = gs.board + bin_input_data = np.zeros(shape=[1] + self.model.bin_input_shape, dtype=np.float32) + global_input_data = np.zeros(shape=[1] + self.model.global_input_shape, dtype=np.float32) + pla = board.pla + opp = Board.get_opp(pla) + move_idx = len(gs.moves) + self.features.fill_row_features(board, pla, opp, gs.boards, gs.moves, move_idx, rules, bin_input_data, + global_input_data, + idx=0) + + locs_and_values = [] + for y in range(board.size): + for x in range(board.size): + loc = board.loc(x, y) + pos = self.features.loc_to_tensor_pos(loc, board) + locs_and_values.append((loc, bin_input_data[0, pos, feature_idx])) + return locs_and_values + + def print_scorebelief(self, gs, outputs): + board = gs.board + scorebelief = outputs["scorebelief"] + lead = outputs["lead"] + scoremean = outputs["scoremean"] + scorestdev = outputs["scorestdev"] + + scorebelief = list(scorebelief) + # Flip so that it's in perspective of the player playing + if board.pla != Board.WHITE: + scorebelief.reverse() + scoremean = -scoremean + lead = -lead + + scoredistrmid = self.pos_len * self.pos_len + EXTRA_SCORE_DISTR_RADIUS + ret = "" + ret += "TEXT " + ret += "ScoreBelief: \n" + for i in range(17, -1, -1): + ret += "TEXT " + ret += "%+6.1f" % (-(i * 20 + 0.5)) + for j in range(20): + idx = scoredistrmid - (i * 20 + j) - 1 + ret += " %4.0f" % (scorebelief[idx] * 10000) + ret += "\n" + for i in range(18): + ret += "TEXT " + ret += "%+6.1f" % ((i * 20 + 0.5)) + for j in range(20): + idx = scoredistrmid + (i * 20 + j) + ret += " %4.0f" % (scorebelief[idx] * 10000) + ret += "\n" + + beliefscore = 0 + beliefscoresq = 0 + beliefwin = 0 + belieftotal = 0 + for idx in range(scoredistrmid * 2): + score = idx - scoredistrmid + 0.5 + if score > 0: + beliefwin += scorebelief[idx] + else: + beliefwin -= scorebelief[idx] + belieftotal += scorebelief[idx] + beliefscore += score * scorebelief[idx] + beliefscoresq += score * score * scorebelief[idx] + + beliefscoremean = beliefscore / belieftotal + beliefscoremeansq = beliefscoresq / belieftotal + beliefscorevar = max(0, beliefscoremeansq - beliefscoremean * beliefscoremean) + beliefscorestdev = math.sqrt(beliefscorevar) + + ret += "TEXT BeliefWin: %.2fc\n" % (100 * beliefwin / belieftotal) + ret += "TEXT BeliefScoreMean: %.2f\n" % (beliefscoremean) + ret += "TEXT BeliefScoreStdev: %.2f\n" % (beliefscorestdev) + ret += "TEXT Lead: %.3f\n" % (lead) + ret += "TEXT ScoreMean: %.3f\n" % (scoremean) + ret += "TEXT ScoreStdev: %.3f\n" % (scorestdev) + ret += "TEXT Value: %s\n" % str(["%.3f" % x for x in outputs["value"]]) + ret += "TEXT TDValue: %s\n" % str(["%.3f" % x for x in outputs["td_value"]]) + ret += "TEXT TDValue2: %s\n" % str(["%.3f" % x for x in outputs["td_value2"]]) + ret += "TEXT TDValue3: %s\n" % str(["%.3f" % x for x in outputs["td_value3"]]) + ret += "TEXT TDScore: %s\n" % str(["%.3f" % x for x in outputs["td_score"]]) + ret += "TEXT Estv: %s\n" % str(outputs["estv"]) + ret += "TEXT Ests: %s\n" % str(outputs["ests"]) + ret += "TEXT Vtime: %s\n" % str(outputs["vtime"]) + return ret + + def add_input_feature_visualizations(self, layer_name, feature_idx, normalization_div): + command_name = layer_name + command_name = command_name.replace("/", ":") + known_commands.append(command_name) + known_analyze_commands.append("gfx/" + command_name + "/" + command_name) + input_feature_command_lookup[command_name] = (feature_idx, normalization_div) + + def get_board_matrix_str(self, matrix, scale, formatstr): + ret = "" + matrix = matrix.reshape([self.features.pos_len, self.features.pos_len]) + for y in range(self.features.pos_len): + for x in range(self.features.pos_len): + ret += formatstr % (scale * matrix[y, x]) + ret += " " + ret += "\n" + return ret + + def katago_command(self, game_state, command, to_play=None): + """ + command = ['play', 'b', 'a4'] + command = ['play', 'w', 'a4'] + command = ['genmove', 'w', 'a4'] + command = ['get_katago_action'] + command = ['boardsize', 9] + command = ["showboard"] + """ + gs = game_state + if re.match('\d+', command[0]): + cmdid = command[0] + command = command[1:] + else: + cmdid = '' + + ret = '' + if command[0] == "showboard": + ret = "\n" + gs.board.to_string().strip() + elif command[0] == "komi": + rules["whiteKomi"] = float(command[1]) + elif command[0] == "play": + pla = (Board.BLACK if command[1] == "B" or command[1] == "b" else Board.WHITE) + loc = parse_coord(command[2], gs.board) + gs.board.play(pla, loc) + gs.moves.append((pla, loc)) + gs.boards.append(gs.board.copy()) + return gs + elif command[0] == "genmove": + outputs = self.get_outputs(gs, rules) + loc = outputs["genmove_result"] + pla = gs.board.pla + + if len(command) > 1: + pla = (Board.BLACK if command[1] == "B" or command[1] == "b" else Board.WHITE) + gs.board.play(pla, loc) + gs.moves.append((pla, loc)) + gs.boards.append(gs.board.copy()) + ret = str_coord(loc, gs.board) + + elif command[0] == "get_katago_action": + # NOTE: here bot action may be illegal action in go_lightzero + outputs = self.get_outputs(gs, rules) + if to_play == 1: + moves_and_probs0 = outputs["moves_and_probs0"] + moves_and_probs = sorted(moves_and_probs0, key=lambda moveandprob: moveandprob[1], reverse=True) + katago_flatten_action = moves_and_probs[0][0] + if self.ignore_pass_if_have_other_legal_actions and len(moves_and_probs) > 1: + if katago_flatten_action == Board.PASS_LOC: # 0 + katago_flatten_action = moves_and_probs[1][0] + # TODO + # print('ignore_pass_if_have_other_legal_actions now!') + elif to_play == 2: + moves_and_probs1 = outputs["moves_and_probs1"] + moves_and_probs = sorted(moves_and_probs1, key=lambda moveandprob: moveandprob[1], reverse=True) + katago_flatten_action = moves_and_probs[0][0] # moves_and_probs[0]: (katago_flatten_action, prior) + if self.ignore_pass_if_have_other_legal_actions and len(moves_and_probs)>1: + if katago_flatten_action == Board.PASS_LOC: # 0 + katago_flatten_action = moves_and_probs[1][0] + # print('ignore_pass_if_have_other_legal_actions now!') + + # gtp_action = str_coord(katago_flatten_action, gs.board) + lz_flatten_action = katago_flatten_to_lz_flatten(katago_flatten_action, gs.board) + return lz_flatten_action + + elif command[0] == "name": + ret = 'KataGo Raw Neural Net Debug/Test Script' + elif command[0] == "version": + ret = '1.0' + elif command[0] == "list_commands": + ret = '\n'.join(known_commands) + elif command[0] == "known_command": + ret = 'true' if command[1] in known_commands else 'false' + elif command[0] == "gogui-analyze_commands": + ret = '\n'.join(known_analyze_commands) + elif command[0] == "setrule": + ret = "" + if command[1] == "korule": + rules["koRule"] = command[2].upper() + elif command[1] == "scoringrule": + rules["scoringRule"] = command[2].upper() + elif command[1] == "taxrule": + rules["taxRule"] = command[2].upper() + elif command[1] == "multistonesuicidelegal": + rules["multiStoneSuicideLegal"] = (command[2].lower() == "true") + elif command[1] == "hasbutton": + rules["hasButton"] = (command[2].lower() == "true") + elif command[1] == "encorephase": + rules["encorePhase"] = int(command[2]) + elif command[1] == "passwouldendphase": + rules["passWouldEndPhase"] = (command[2].lower() == "true") + elif command[1] == "whitekomi" or command[1] == "komi": + rules["whiteKomi"] = float(command[2]) + elif command[1] == "asym": + rules["asymPowersOfTwo"] = float(command[2]) + else: + ret = "Unknown rules setting" + elif command[0] == "policy": + outputs = self.get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["moves_and_probs0"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=outputs) + ret = "\n".join(gfx_commands) + elif command[0] == "policy1": + outputs = self.get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["moves_and_probs1"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=outputs) + ret = "\n".join(gfx_commands) + elif command[0] == "logpolicy": + outputs = self.get_outputs(gs, rules) + moves_and_logprobs = [(move, max(0.0, 4.9 + math.log10(prob))) for (move, prob) in + outputs["moves_and_probs0"]] + gfx_commands = get_gfx_commands_for_heatmap(moves_and_logprobs, gs.board, normalization_div=6, + is_percent=False, + value_and_score_from=outputs) + ret = "\n".join(gfx_commands) + elif command[0] == "ownership": + outputs = self.get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["ownership_by_loc"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=None, hotcold=True) + ret = "\n".join(gfx_commands) + elif command[0] == "scoring": + outputs = self.get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["scoring_by_loc"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=None, hotcold=True) + ret = "\n".join(gfx_commands) + elif command[0] == "futurepos0": + outputs = self.get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["futurepos0_by_loc"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=None, hotcold=True) + ret = "\n".join(gfx_commands) + elif command[0] == "futurepos1": + outputs = self.get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["futurepos1_by_loc"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=None, hotcold=True) + ret = "\n".join(gfx_commands) + elif command[0] == "seki": + outputs = self.get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["seki_by_loc"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=None) + ret = "\n".join(gfx_commands) + elif command[0] == "seki2": + outputs = self.get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["seki_by_loc2"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=None) + ret = "\n".join(gfx_commands) + + elif command[0] == "policy_raw": + outputs = self.get_outputs(gs, rules) + ret = "\n" + policysum = 0.0 + for y in range(gs.board.size): + for x in range(gs.board.size): + loc = gs.board.loc(x, y) + pos = self.features.loc_to_tensor_pos(loc, gs.board) + gs.board.would_be_legal(gs.board.pla, loc) + policysum += outputs["policy0"][pos] + loc = Board.PASS_LOC + pos = self.features.loc_to_tensor_pos(loc, gs.board) + policysum += outputs["policy0"][pos] + + for y in range(gs.board.size): + for x in range(gs.board.size): + loc = gs.board.loc(x, y) + pos = self.features.loc_to_tensor_pos(loc, gs.board) + if gs.board.would_be_legal(gs.board.pla, loc): + ret += "%6.3f" % (100.0 * outputs["policy0"][pos] / policysum) + else: + ret += " - " + ret += " " + ret += "\n" + loc = Board.PASS_LOC + pos = self.features.loc_to_tensor_pos(loc, gs.board) + ret += "Pass: %6.3f" % (100.0 * outputs["policy0"][pos] / policysum) + + elif command[0] == "policy1_raw": + outputs = self.get_outputs(gs, rules) + ret = "\n" + + for y in range(gs.board.size): + for x in range(gs.board.size): + loc = gs.board.loc(x, y) + pos = self.features.loc_to_tensor_pos(loc, gs.board) + if gs.board.would_be_legal(gs.board.pla, loc): + ret += "%6.3f" % (100.0 * outputs["policy1"][pos]) + else: + ret += " - " + ret += " " + ret += "\n" + loc = Board.PASS_LOC + pos = self.features.loc_to_tensor_pos(loc, gs.board) + ret += "Pass: %6.3f" % (100.0 * outputs["policy1"][pos]) + + elif command[0] == "ownership_raw": + outputs = self.get_outputs(gs, rules) + ret = self.get_board_matrix_str(outputs["ownership"], 100.0, "%+7.3f") + elif command[0] == "scoring_raw": + outputs = self.get_outputs(gs, rules) + ret = self.get_board_matrix_str(outputs["scoring"], 100.0, "%+7.3f") + elif command[0] == "futurepos0_raw": + outputs = self.get_outputs(gs, rules) + ret = self.get_board_matrix_str(outputs["futurepos"][0], 100.0, "%+7.3f") + elif command[0] == "futurepos1_raw": + outputs = self.get_outputs(gs, rules) + ret = self.get_board_matrix_str(outputs["futurepos"][1], 100.0, "%+7.3f") + elif command[0] == "seki_raw": + outputs = self.get_outputs(gs, rules) + ret = self.get_board_matrix_str(outputs["seki"], 100.0, "%+7.3f") + elif command[0] == "seki2_raw": + outputs = self.get_outputs(gs, rules) + ret = self.get_board_matrix_str(outputs["seki2"], 100.0, "%+7.3f") + + elif command[0] in input_feature_command_lookup: + (feature_idx, normalization_div) = input_feature_command_lookup[command[0]] + locs_and_values = self.get_input_feature(gs, rules, feature_idx) + gfx_commands = get_gfx_commands_for_heatmap(locs_and_values, gs.board, normalization_div, is_percent=False) + ret = "\n".join(gfx_commands) + + elif command[0] == "passalive": + locs_and_values = get_pass_alive(gs.board, rules) + gfx_commands = get_gfx_commands_for_heatmap(locs_and_values, gs.board, normalization_div=None, + is_percent=False) + ret = "\n".join(gfx_commands) + + elif command[0] == "scorebelief": + outputs = self.get_outputs(gs, rules) + ret = self.print_scorebelief(gs, outputs) + + elif command[0] == "protocol_version": + ret = '2' + elif command[0] == "quit": + print('=%s \n\n' % (cmdid,), end='') + else: + print('Warning: Ignoring unknown command - %s' % (line,), file=sys.stderr) + ret = None + + if ret is not None: + print('=%s %s\n\n' % (cmdid, ret,), end='') + else: + print('?%s ???\n\n' % (cmdid,), end='') + sys.stdout.flush() diff --git a/zoo/board_games/go/envs/test_go_mcts_bot.py b/zoo/board_games/go/envs/test_go_mcts_bot.py index d7686778f..7abf407e8 100644 --- a/zoo/board_games/go/envs/test_go_mcts_bot.py +++ b/zoo/board_games/go/envs/test_go_mcts_bot.py @@ -1,5 +1,5 @@ from easydict import EasyDict -from zoo.board_games.go.envs.go_env import GoEnv +from zoo.board_games.go.envs.go_env import GoEnv, flatten_action_to_gtp_action from zoo.board_games.mcts_bot import MCTSBot import pytest @@ -9,8 +9,13 @@ cfg = EasyDict(dict( board_size=6, num_simulations=80, - # num_simulations=20, # board_size=5, + # num_simulations=20, + save_gif_replay=False, + render_in_ui=False, + katago_checkpoint_path="/Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", + ignore_pass_if_have_other_legal_actions=True, + save_gif_path='./', komi=7.5, prob_random_agent=0, prob_expert_agent=0, @@ -27,163 +32,194 @@ @pytest.mark.envtest class TestGoBot: - def test_go_mcts_vs_human(self): - # player_0 num_simulation=1000, will win - # player_1 num_simulation=1 - env = GoEnv(cfg) - obs = env.reset() - state = obs['board'] - player_1 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 - - player_index = 0 # player 1 first - print('#' * 15) - print(state) - while not env.get_done_reward()[0]: - if player_index == 0: - action = player_1.get_actions(state, player_index=player_index) - player_index = 1 - else: - print('-' * 40) - # action = player_2.get_actions(state, player_index=player_index) - # action = env.random_action() - action = env.human_to_action() - player_index = 0 - - timestep = env.step(action) - env.render('human') - # time.sleep(0.1) - state = timestep.obs['board'] - print('-' * 40) - print(state) - assert env.get_done_winner()[1] == 1, f'winner is {env.get_done_winner()[1]}, player 1 should win' - - def test_go_mcts_vs_random(self): - # player_0 num_simulation=1000, will win - # player_1 num_simulation=1 - env = GoEnv(cfg) - obs = env.reset() - state = obs['board'] - player_1 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 + # def test_go_mcts_vs_human(self): + # # player_0 num_simulation=1000, will win + # # player_1 num_simulation=1 + # env = GoEnv(cfg) + # obs = env.reset() + # state = obs['board'] + # player_1 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 + # + # player_index = 0 # player 1 first + # print('#' * 15) + # print(state) + # while not env.get_done_reward()[0]: + # if player_index == 0: + # action = player_1.get_actions(state, player_index=player_index) + # player_index = 1 + # else: + # print('-' * 40) + # # action = player_2.get_actions(state, player_index=player_index) + # # action = env.random_action() + # action = env.human_to_action() + # player_index = 0 + # + # timestep = env.step(action) + # env.render('human') + # # time.sleep(0.1) + # state = timestep.obs['board'] + # print('-' * 40) + # print(state) + # assert env.get_done_winner()[1] == 1, f'winner is {env.get_done_winner()[1]}, player 1 should win' + # + # def test_go_mcts_vs_random(self): + # # player_0 num_simulation=1000, will win + # # player_1 num_simulation=1 + # env = GoEnv(cfg) + # obs = env.reset() + # state = obs['board'] + # player_1 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 + # + # player_index = 0 # player 1 first + # print('#' * 15) + # print(state) + # print('#' * 15) + # while not env.get_done_reward()[0]: + # if player_index == 0: + # action = player_1.get_actions(state, player_index=player_index) + # player_index = 1 + # else: + # print('-' * 40) + # # action = player_2.get_actions(state, player_index=player_index) + # action = env.random_action() + # player_index = 0 + # + # timestep = env.step(action) + # # env.render('human') + # # time.sleep(0.1) + # state = timestep.obs['board'] + # print('-' * 40) + # print(state) + # assert env.get_done_winner()[1] == 1, f'winner is {env.get_done_winner()[1]}, player 1 should win' + # + # def test_go_self_play_mode_player1_win(self): + # # player_0 num_simulation=1000, will win + # # player_1 num_simulation=1 + # env = GoEnv(cfg) + # obs = env.reset() + # state = obs['board'] + # player_1 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 + # player_2 = MCTSBot(GoEnv, cfg, 'player 2', int(cfg.num_simulations/2)) # player_index = 1, player = 2 + # + # player_index = 0 # player 1 first + # print('#' * 15) + # print(state) + # print('#' * 15) + # while not env.get_done_reward()[0]: + # if player_index == 0: + # action = player_1.get_actions(state, player_index=player_index) + # player_index = 1 + # else: + # print('-' * 40) + # action = player_2.get_actions(state, player_index=player_index) + # player_index = 0 + # timestep = env.step(action) + # state = timestep.obs['board'] + # print('-' * 40) + # print(state) + # assert env.get_done_winner()[1] == 1, f'winner is {env.get_done_winner()[1]}, player 1 should win' + # + # def test_go_self_play_mode_player2_win(self): + # # player_0 num_simulation=1 + # # player_1 num_simulation=1000, will win + # env = GoEnv(cfg) + # obs = env.reset() + # state = obs['board'] + # player_1 = MCTSBot(GoEnv, cfg, 'player 1', 1) # player_index = 0, player = 1 + # player_2 = MCTSBot(GoEnv, cfg, 'player 2', cfg.num_simulations) # player_index = 1, player = 2 + # + # player_index = 0 # player 1 first + # print('#' * 15) + # print(state) + # print('#' * 15) + # while not env.get_done_reward()[0]: + # if player_index == 0: + # action = player_1.get_actions(state, player_index=player_index) + # player_index = 1 + # else: + # print('-' * 40) + # action = player_2.get_actions(state, player_index=player_index) + # player_index = 0 + # timestep = env.step(action) + # state = timestep.obs['board'] + # print('-' * 40) + # print(state) + # assert env.get_done_winner()[1] == 2, f'winner is {env.get_done_winner()[1]}, player 2 should win' + # + # def test_go_self_play_mode_draw(self): + # # player_0 num_simulation=1000 + # # player_1 num_simulation=1000, will draw + # cfg.num_simulations = 50 + # + # env = GoEnv(cfg) + # obs = env.reset() + # state = obs['board'] + # + # player_1 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 + # player_2 = MCTSBot(GoEnv, cfg, 'player 2', cfg.num_simulations) # player_index = 1, player = 2 + # + # player_index = 0 # player 1 fist + # print(state) + # print('-' * 40) + # while not env.get_done_reward()[0]: + # if player_index == 0: + # action = player_1.get_actions(state, player_index=player_index) + # player_index = 1 + # else: + # print('-' * 40) + # action = player_2.get_actions(state, player_index=player_index) + # player_index = 0 + # timestep = env.step(action) + # + # env.render('human') + # # time.sleep(0.1) + # + # state = timestep.obs['board'] + # print('-' * 40) + # print(state) + # assert env.get_done_winner()[1] == -1, f'winner is {env.get_done_winner()[1]}, two players should draw' + # - player_index = 0 # player 1 first - print('#' * 15) - print(state) - print('#' * 15) - while not env.get_done_reward()[0]: - if player_index == 0: - action = player_1.get_actions(state, player_index=player_index) - player_index = 1 - else: - print('-' * 40) - # action = player_2.get_actions(state, player_index=player_index) - action = env.random_action() - player_index = 0 - - timestep = env.step(action) - # env.render('human') - # time.sleep(0.1) - state = timestep.obs['board'] - print('-' * 40) - print(state) - assert env.get_done_winner()[1] == 1, f'winner is {env.get_done_winner()[1]}, player 1 should win' - - def test_go_self_play_mode_player1_win(self): - # player_0 num_simulation=1000, will win - # player_1 num_simulation=1 - env = GoEnv(cfg) - obs = env.reset() - state = obs['board'] - player_1 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 - player_2 = MCTSBot(GoEnv, cfg, 'player 2', int(cfg.num_simulations/2)) # player_index = 1, player = 2 - player_index = 0 # player 1 first - print('#' * 15) - print(state) - print('#' * 15) - while not env.get_done_reward()[0]: - if player_index == 0: - action = player_1.get_actions(state, player_index=player_index) - player_index = 1 - else: - print('-' * 40) - action = player_2.get_actions(state, player_index=player_index) - player_index = 0 - timestep = env.step(action) - state = timestep.obs['board'] - print('-' * 40) - print(state) - assert env.get_done_winner()[1] == 1, f'winner is {env.get_done_winner()[1]}, player 1 should win' - - def test_go_self_play_mode_player2_win(self): - # player_0 num_simulation=1 - # player_1 num_simulation=1000, will win + def test_go_self_play_mode_case_1(self): env = GoEnv(cfg) - obs = env.reset() - state = obs['board'] - player_1 = MCTSBot(GoEnv, cfg, 'player 1', 1) # player_index = 0, player = 1 - player_2 = MCTSBot(GoEnv, cfg, 'player 2', cfg.num_simulations) # player_index = 1, player = 2 - - player_index = 0 # player 1 first - print('#' * 15) - print(state) - print('#' * 15) - while not env.get_done_reward()[0]: - if player_index == 0: - action = player_1.get_actions(state, player_index=player_index) - player_index = 1 - else: - print('-' * 40) - action = player_2.get_actions(state, player_index=player_index) - player_index = 0 - timestep = env.step(action) - state = timestep.obs['board'] - print('-' * 40) - print(state) - assert env.get_done_winner()[1] == 2, f'winner is {env.get_done_winner()[1]}, player 2 should win' - - def test_go_self_play_mode_draw(self): - # player_0 num_simulation=1000 - # player_1 num_simulation=1000, will draw - cfg.num_simulations = 50 + init_state = np.array([ + [-1, -1, 1, -1, 0, 0], + [ 0, 0, 0, 0, -1, 0], + [ 0, 0, 0, 0, 0, -1], + [ 0, 0, 0, 0, 1, 0], + [-1, 0, 0, -1, -1, 1], + [ 0, -1, 0, 1, 1, 0], + ]) - env = GoEnv(cfg) - obs = env.reset() - state = obs['board'] + # TODO + cfg.num_simulations = 500 player_1 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 player_2 = MCTSBot(GoEnv, cfg, 'player 2', cfg.num_simulations) # player_index = 1, player = 2 - player_index = 0 # player 1 fist + + obs = env.reset(player_index, init_state) + state = obs['board'] print(state) - print('-' * 40) + print('#' * 15) + while not env.get_done_reward()[0]: if player_index == 0: action = player_1.get_actions(state, player_index=player_index) - player_index = 1 - else: - print('-' * 40) - action = player_2.get_actions(state, player_index=player_index) - player_index = 0 - timestep = env.step(action) - - env.render('human') - # time.sleep(0.1) + print(f"mcts_gtp_action: {flatten_action_to_gtp_action(action, cfg.board_size)} for case 1") + break - state = timestep.obs['board'] - print('-' * 40) - print(state) - assert env.get_done_winner()[1] == -1, f'winner is {env.get_done_winner()[1]}, two players should draw' - - def test_go_self_play_mode_case_1(self): + def test_go_self_play_mode_case_2(self): env = GoEnv(cfg) init_state = np.array([ - [0, 0, 0, -1, -1], - [0, 0, 1, 1, -1], - [0, 1, -1, 1, -1], - [0, 0, 0, 1, -1], - [0, 0, 0, 0, 1], + [ 0, 0, 0, 0, 0, 0], + [-1, 0, 0, 0, -1, 0], + [ 0, -1, 0, 0, -1, 0], + [-1, -1, 1, 1, -1, -1], + [ 1, 1, 0, 0, 1, 1], + [ 0, 0, 0, 0, 0, 0], ]) - # TODO cfg.num_simulations = 50 @@ -199,24 +235,25 @@ def test_go_self_play_mode_case_1(self): while not env.get_done_reward()[0]: if player_index == 0: action = player_1.get_actions(state, player_index=player_index) - assert action == 2 + print(f"mcts_gtp_action: {flatten_action_to_gtp_action(action, cfg.board_size)} for case 2") + break - def test_go_self_play_mode_case_2(self): + def test_go_self_play_mode_case_3(self): env = GoEnv(cfg) init_state = np.array([ - [0, 0, 1, 1, 1], - [0, 0, -1, -1, 1], - [0, 0, 0, -1, 1], - [0, 0, 0, -1, 1], - [0, 0, 0, 0, -1], + [ 1, 1, 1, 1, 0, 0], + [ 1, -1, -1, 1, 1, 1], + [ 1, 0, 0, -1, -1, 1], + [ 1, -1, 0, 1, -1, 1], + [ 1, -1, 1, 1, -1, 1], + [-1, -1, -1, -1, -1, 1], ]) - # TODO - cfg.num_simulations = 50 + cfg.num_simulations = 500 player_1 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 player_2 = MCTSBot(GoEnv, cfg, 'player 2', cfg.num_simulations) # player_index = 1, player = 2 - player_index = 1 # player 2 fist + player_index = 0 # player 1 fist obs = env.reset(player_index, init_state) state = obs['board'] @@ -224,13 +261,13 @@ def test_go_self_play_mode_case_2(self): print('#' * 15) while not env.get_done_reward()[0]: - if player_index == 1: - action = player_2.get_actions(state, player_index=player_index) - assert action == 1 - + if player_index == 0: + action = player_1.get_actions(state, player_index=player_index) + print(f"mcts_gtp_action: {flatten_action_to_gtp_action(action, cfg.board_size)} for case 3") + break # test = TestGoBot().test_go_self_play_mode_player1_win() # test = TestGoBot().test_go_self_play_mode_draw() -# test = TestGoBot().test_go_self_play_mode_case_2() -test = TestGoBot().test_go_mcts_vs_human() +# test = TestGoBot().test_go_mcts_vs_human() +test = TestGoBot().test_go_self_play_mode_case_1() diff --git a/zoo/board_games/go/envs/test_katago_bot.py b/zoo/board_games/go/envs/test_katago_bot.py index b1e2b789c..55fe46d39 100644 --- a/zoo/board_games/go/envs/test_katago_bot.py +++ b/zoo/board_games/go/envs/test_katago_bot.py @@ -4,14 +4,21 @@ import pytest from easydict import EasyDict -from zoo.board_games.go.envs.go_env import GoEnv -from zoo.board_games.go.envs.katago_play_for_lightzero import str_coord - +from zoo.board_games.go.envs.go_env import GoEnv, flatten_action_to_gtp_action +from zoo.board_games.go.envs.katago_policy_for_lightzero import str_coord cfg = EasyDict( + board_size=19, # board_size=9, - board_size=6, - + # board_size=6, + save_gif_replay=True, + render_in_ui=True, + # save_gif_replay=False, + # render_in_ui=False, + katago_checkpoint_path="/Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", + ignore_pass_if_have_other_legal_actions=True, + save_gif_path='./', komi=7.5, + # komi=7, battle_mode='self_play_mode', prob_random_agent=0, channel_last=False, @@ -31,13 +38,13 @@ def test_katago_bot(self): env = GoEnv(cfg) test_episodes = 1 - for _ in range(test_episodes): - print('NOTE：actions are counted by column, such as action 9, which is the second column and the first row') + for i in range(test_episodes): + print(f'episode {i}') + print('='*20) + obs = env.reset() - print(obs['observation'].shape, obs['action_mask'].shape) - print(obs['observation'], obs['action_mask']) - actions_black = [0, 2, 0] - actions_white = [1, 6] + # print(obs['observation'].shape, obs['action_mask'].shape) + # print(obs['observation'], obs['action_mask']) # env.render() # TODO(pu): katago_game_state init turn = 0 @@ -45,7 +52,11 @@ def test_katago_bot(self): turn += 1 print('turn: ', turn) # ****** player 1's turn ****** + # bot_action = env.random_action() + # bot_action = env.human_to_action() + # bot_action = env.human_to_gtp_action() bot_action = env.get_katago_action(to_play=1) + if bot_action not in env.legal_actions: logging.warning( f"You input illegal *bot* action: {bot_action}, the legal_actions are {env.legal_actions}. " @@ -57,9 +68,8 @@ def test_katago_bot(self): katago_flatten_action = env.lz_flatten_to_katago_flatten(bot_action, env.board_size) print('player 1:', str_coord(katago_flatten_action, env.katago_game_state.board)) env.update_katago_internal_game_state(katago_flatten_action, to_play=1) + action = bot_action - # action = env.human_to_action() - # action = env.random_action() # action = actions_black[i] # print('player 1 (black): ', action) obs, reward, done, info = env.step(action) @@ -69,7 +79,6 @@ def test_katago_bot(self): assert isinstance(done, bool) assert isinstance(reward, float) or isinstance(reward, int) # env.render('board') - env.render('human') if done: if reward > 0: @@ -81,6 +90,7 @@ def test_katago_bot(self): break # ****** player 2's turn ****** + # bot_action = env.human_to_gtp_action() bot_action = env.get_katago_action(to_play=2) if bot_action not in env.legal_actions: logging.warning( @@ -103,7 +113,7 @@ def test_katago_bot(self): # print(self.board) # print(obs, reward, done, info) # env.render('board') - env.render('human') + if done: if reward > 0: print('player 2 (white) win') @@ -113,4 +123,4 @@ def test_katago_bot(self): print('draw') break -TestKataGoBot().test_katago_bot() \ No newline at end of file +# TestKataGoBot().test_katago_bot() \ No newline at end of file diff --git a/zoo/board_games/gomoku/envs/gomoku_env.py b/zoo/board_games/gomoku/envs/gomoku_env.py index 684f861fa..e78444b03 100644 --- a/zoo/board_games/gomoku/envs/gomoku_env.py +++ b/zoo/board_games/gomoku/envs/gomoku_env.py @@ -111,7 +111,7 @@ def __init__(self, cfg: dict = None): if self.bot_action_type == 'alpha_beta_pruning': self.alpha_beta_pruning_player = AlphaBetaPruningBot(self, cfg, 'alpha_beta_pruning_player') - def reset(self, start_player_index=0, init_state=None): + def reset(self, start_player_index=0, init_state=None, katago_policy_init=False): self._observation_space = gym.spaces.Box( low=0, high=2, shape=(self.board_size, self.board_size, 3), dtype=np.int32 ) diff --git a/zoo/board_games/mcts_bot.py b/zoo/board_games/mcts_bot.py index b36413aa6..10e9403c4 100644 --- a/zoo/board_games/mcts_bot.py +++ b/zoo/board_games/mcts_bot.py @@ -232,7 +232,7 @@ def __init__(self, ENV, cfg, bot_name, num_simulation=10000): def get_actions(self, state, player_index): simulator_env = self.ENV(EasyDict(self.cfg)) - simulator_env.reset(start_player_index=player_index, init_state=state) + simulator_env.reset(start_player_index=player_index, init_state=state, katago_policy_init=False) # legal_actions = simulator_env.legal_actions root = TwoPlayersMCTSNode(simulator_env) mcts = MCTSSearchNode(root) diff --git a/zoo/board_games/tictactoe/envs/tictactoe_env.py b/zoo/board_games/tictactoe/envs/tictactoe_env.py index 01ef5d17f..ef988a953 100644 --- a/zoo/board_games/tictactoe/envs/tictactoe_env.py +++ b/zoo/board_games/tictactoe/envs/tictactoe_env.py @@ -107,7 +107,7 @@ def get_done_winner(self): # Convert NumPy arrays to nested tuples to make them hashable. return _get_done_winner_func_lru(tuple(map(tuple, self.board))) - def reset(self, start_player_index=0, init_state=None): + def reset(self, start_player_index=0, init_state=None, katago_policy_init=False): """ Overview: Env reset and custom state start by init_state From 5b68ba9d03c72b62278d08cd1611168fe0756f6c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Thu, 6 Jul 2023 05:32:46 +0800 Subject: [PATCH 19/34] fix(pu): fix katago_policy cuda bug --- lzero/entry/train_alphazero.py | 7 +++++++ zoo/atari/config/atari_efficientzero_config.py | 18 +++++++++++++----- .../go/config/go_alphazero_sp_mode_config.py | 11 ++++++++--- zoo/board_games/go/envs/go_env.py | 12 ++++++++---- zoo/board_games/go/envs/katago_policy.py | 13 +++++++++---- zoo/board_games/go/envs/test_katago_bot.py | 2 +- 6 files changed, 46 insertions(+), 17 deletions(-) diff --git a/lzero/entry/train_alphazero.py b/lzero/entry/train_alphazero.py index 3b455adb1..b5acfd49f 100644 --- a/lzero/entry/train_alphazero.py +++ b/lzero/entry/train_alphazero.py @@ -14,6 +14,7 @@ from lzero.policy import visit_count_temperature from lzero.worker import AlphaZeroCollector, AlphaZeroEvaluator +from zoo.board_games.go.envs.katago_policy import KatagoPolicy def train_alphazero( @@ -51,8 +52,14 @@ def train_alphazero( cfg.policy.device = 'cpu' cfg = compile_config(cfg, seed=seed, env=None, auto=True, create_cfg=create_cfg, save_cfg=True) + + if cfg.env.use_katago_bot: + cfg.env.katago_model = KatagoPolicy(checkpoint_path=cfg.env.katago_checkpoint_path, board_size=cfg.env.board_size, + ignore_pass_if_have_other_legal_actions=cfg.env.ignore_pass_if_have_other_legal_actions, device=cfg.policy.device) + # Create main components: env, policy env_fn, collector_env_cfg, evaluator_env_cfg = get_vec_env_setting(cfg.env) + collector_env = create_env_manager(cfg.env.manager, [partial(env_fn, cfg=c) for c in collector_env_cfg]) evaluator_env = create_env_manager(cfg.env.manager, [partial(env_fn, cfg=c) for c in evaluator_env_cfg]) collector_env.seed(cfg.seed) diff --git a/zoo/atari/config/atari_efficientzero_config.py b/zoo/atari/config/atari_efficientzero_config.py index 6d6af6a1f..3d2794517 100644 --- a/zoo/atari/config/atari_efficientzero_config.py +++ b/zoo/atari/config/atari_efficientzero_config.py @@ -17,12 +17,20 @@ # ============================================================== # begin of the most frequently changed config specified by the user # ============================================================== -collector_env_num = 8 -n_episode = 8 -evaluator_env_num = 3 -num_simulations = 50 +# collector_env_num = 8 +# n_episode = 8 +# evaluator_env_num = 3 +# num_simulations = 50 +# update_per_collect = 1000 +# batch_size = 256 +# max_env_step = int(1e6) +# reanalyze_ratio = 0. +collector_env_num = 1 +n_episode = 1 +evaluator_env_num = 1 +num_simulations = 5 update_per_collect = 1000 -batch_size = 256 +batch_size = 2 max_env_step = int(1e6) reanalyze_ratio = 0. # ============================================================== diff --git a/zoo/board_games/go/config/go_alphazero_sp_mode_config.py b/zoo/board_games/go/config/go_alphazero_sp_mode_config.py index c11ad86a5..dbbdc10b2 100644 --- a/zoo/board_games/go/config/go_alphazero_sp_mode_config.py +++ b/zoo/board_games/go/config/go_alphazero_sp_mode_config.py @@ -26,7 +26,7 @@ elif board_size == 6: num_simulations = 80 -# board_size = 9 +# board_size = 6 # collector_env_num = 1 # n_episode = 1 # evaluator_env_num = 1 @@ -44,8 +44,10 @@ env=dict( board_size=board_size, komi=komi, - katago_checkpoint_path="/Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", - # katago_checkpoint_path="/mnt/nfs/puyuan/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", + use_katago_bot=True, + # katago_checkpoint_path="/Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", + katago_checkpoint_path="/mnt/nfs/puyuan/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", + device='cuda', battle_mode='self_play_mode', bot_action_type='v0', prob_random_action_in_bot=0, @@ -114,6 +116,9 @@ create_config = go_alphazero_create_config if __name__ == '__main__': + # To make sure katago policy model tp_device correctly + # import multiprocessing + # multiprocessing.set_start_method('spawn', force=True) if main_config.policy.tensor_float_32: import torch diff --git a/zoo/board_games/go/envs/go_env.py b/zoo/board_games/go/envs/go_env.py index 90eb9b194..bc840e65f 100644 --- a/zoo/board_games/go/envs/go_env.py +++ b/zoo/board_games/go/envs/go_env.py @@ -16,11 +16,12 @@ from pettingzoo.classic.go.go import raw_env from pettingzoo.utils.agent_selector import agent_selector -from zoo.board_games.go.envs.katago_policy_for_lightzero import str_coord, GameState, str_coord, KatagoPolicy +from zoo.board_games.go.envs.katago_policy import str_coord, GameState, str_coord, KatagoPolicy import imageio import time + def get_image(path): from os import path as os_path @@ -90,6 +91,8 @@ class GoEnv(BaseEnv): channel_last=True, scale=True, ignore_pass_if_have_other_legal_actions=True, + device='cpu', + katago_model=None, ) @classmethod @@ -175,9 +178,10 @@ def __init__(self, cfg=None): self.render_in_ui = cfg.render_in_ui self.katago_checkpoint_path= cfg.katago_checkpoint_path self.ignore_pass_if_have_other_legal_actions = cfg.ignore_pass_if_have_other_legal_actions - - self.katago_policy = KatagoPolicy(checkpoint_path=self.katago_checkpoint_path, board_size=self.board_size, - ignore_pass_if_have_other_legal_actions=self.ignore_pass_if_have_other_legal_actions) + self.device = cfg.device + self.katago_policy = cfg.katago_model + # self.katago_policy = KatagoPolicy(checkpoint_path=self.katago_checkpoint_path, board_size=self.board_size, + # ignore_pass_if_have_other_legal_actions=self.ignore_pass_if_have_other_legal_actions, device=self.device) # Represent a board as a numpy array, with 0 empty, 1 is black, -1 is white. def reset(self, start_player_index=0, init_state=None, katago_policy_init=True): diff --git a/zoo/board_games/go/envs/katago_policy.py b/zoo/board_games/go/envs/katago_policy.py index 80af69941..1684d6af0 100644 --- a/zoo/board_games/go/envs/katago_policy.py +++ b/zoo/board_games/go/envs/katago_policy.py @@ -5,8 +5,10 @@ import sys # 将 Katago 项目的路径添加到 sys.path 中 -sys.path.append(os.path.abspath('/Users/puyuan/code/KataGo/')) -sys.path.append(os.path.abspath('/Users/puyuan/code/KataGo/python')) +# sys.path.append(os.path.abspath('/Users/puyuan/code/KataGo/')) +# sys.path.append(os.path.abspath('/Users/puyuan/code/KataGo/python')) +sys.path.append(os.path.abspath('/mnt/nfs/puyuan/KataGo/')) +sys.path.append(os.path.abspath('/mnt/nfs/puyuan/KataGo/python')) import argparse import math @@ -354,7 +356,8 @@ def lerp(p, x0, x1, y0, y1): class KatagoPolicy(): def __init__(self, checkpoint_path="/Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", - board_size=9, ignore_pass_if_have_other_legal_actions=False): + board_size=9, ignore_pass_if_have_other_legal_actions=False, device='cpu'): + self.device = device self.load_katago_model(checkpoint_path, board_size) for i in range(self.model.bin_input_shape[1]): self.add_input_feature_visualizations("input-" + str(i), i, normalization_div=1) @@ -394,7 +397,9 @@ def load_katago_model(self, np.set_printoptions(linewidth=150) torch.set_printoptions(precision=7, sci_mode=False, linewidth=100000, edgeitems=1000, threshold=1000000) - model, swa_model, _ = load_model(checkpoint_file, use_swa, device="cpu", pos_len=self.pos_len, verbose=True) + # model, swa_model, _ = load_model(checkpoint_file, use_swa, device="cpu", pos_len=self.pos_len, verbose=True) + model, swa_model, _ = load_model(checkpoint_file, use_swa, device=self.device, pos_len=self.pos_len, verbose=True) + model.eval() model_config = model.config if swa_model is not None: diff --git a/zoo/board_games/go/envs/test_katago_bot.py b/zoo/board_games/go/envs/test_katago_bot.py index 55fe46d39..72399390a 100644 --- a/zoo/board_games/go/envs/test_katago_bot.py +++ b/zoo/board_games/go/envs/test_katago_bot.py @@ -5,7 +5,7 @@ from easydict import EasyDict from zoo.board_games.go.envs.go_env import GoEnv, flatten_action_to_gtp_action -from zoo.board_games.go.envs.katago_policy_for_lightzero import str_coord +from zoo.board_games.go.envs.katago_policy import str_coord cfg = EasyDict( board_size=19, # board_size=9, From b975913179cb9454cc9826765780eca28828c287 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Thu, 6 Jul 2023 18:02:04 +0800 Subject: [PATCH 20/34] polish(pu): polish katago_policy init --- lzero/entry/eval_alphazero.py | 6 + lzero/entry/train_alphazero.py | 2 +- .../go/config/go_alphazero_eval_config.py | 11 +- .../go/config/go_alphazero_sp_mode_config.py | 19 +- zoo/board_games/go/envs/go_env.py | 111 ++-- zoo/board_games/go/envs/katago_policy.py | 539 +++++++++--------- zoo/board_games/go/envs/test_katago_bot.py | 20 +- 7 files changed, 353 insertions(+), 355 deletions(-) diff --git a/lzero/entry/eval_alphazero.py b/lzero/entry/eval_alphazero.py index f636b6873..a610009f3 100644 --- a/lzero/entry/eval_alphazero.py +++ b/lzero/entry/eval_alphazero.py @@ -12,6 +12,7 @@ from ding.policy import create_policy from ding.utils import set_pkg_seed from lzero.worker import AlphaZeroEvaluator +from zoo.board_games.go.envs.katago_policy import KatagoPolicy def eval_alphazero( @@ -47,6 +48,11 @@ def eval_alphazero( cfg.policy.device = 'cpu' cfg = compile_config(cfg, seed=seed, env=None, auto=True, create_cfg=create_cfg, save_cfg=True) + + if cfg.env.use_katago_bot: + cfg.env.katago_policy = KatagoPolicy(checkpoint_path=cfg.env.katago_checkpoint_path, board_size=cfg.env.board_size, + ignore_pass_if_have_other_legal_actions=cfg.env.ignore_pass_if_have_other_legal_actions, device=cfg.policy.device) + # Create main components: env, policy env_fn, collector_env_cfg, evaluator_env_cfg = get_vec_env_setting(cfg.env) collector_env = create_env_manager(cfg.env.manager, [partial(env_fn, cfg=c) for c in collector_env_cfg]) diff --git a/lzero/entry/train_alphazero.py b/lzero/entry/train_alphazero.py index b5acfd49f..42c081904 100644 --- a/lzero/entry/train_alphazero.py +++ b/lzero/entry/train_alphazero.py @@ -54,7 +54,7 @@ def train_alphazero( cfg = compile_config(cfg, seed=seed, env=None, auto=True, create_cfg=create_cfg, save_cfg=True) if cfg.env.use_katago_bot: - cfg.env.katago_model = KatagoPolicy(checkpoint_path=cfg.env.katago_checkpoint_path, board_size=cfg.env.board_size, + cfg.env.katago_policy = KatagoPolicy(checkpoint_path=cfg.env.katago_checkpoint_path, board_size=cfg.env.board_size, ignore_pass_if_have_other_legal_actions=cfg.env.ignore_pass_if_have_other_legal_actions, device=cfg.policy.device) # Create main components: env, policy diff --git a/zoo/board_games/go/config/go_alphazero_eval_config.py b/zoo/board_games/go/config/go_alphazero_eval_config.py index a95d0c5bb..1c67c144e 100644 --- a/zoo/board_games/go/config/go_alphazero_eval_config.py +++ b/zoo/board_games/go/config/go_alphazero_eval_config.py @@ -4,6 +4,8 @@ from lzero.entry import eval_alphazero import numpy as np +from zoo.board_games.go.envs.katago_policy import KatagoPolicy + if __name__ == '__main__': """ model_path (:obj:`Optional[str]`): The pretrained model path, which should @@ -13,19 +15,22 @@ # model_path = './ckpt/ckpt_best.pth.tar' model_path = '/Users/puyuan/code/LightZero/tb_go_b9_sp/ckpt_best.pth.tar' # model_path = None - + main_config.env.use_katago_bot = True seeds = [0] - num_episodes_each_seed = 3 + num_episodes_each_seed = 1 # If True, you can play with the agent. main_config.env.agent_vs_human = False # main_config.env.agent_vs_human = True main_config.env.save_gif_replay = True main_config.env.render_in_ui = True - create_config.env_manager.type = 'base' + # main_config.env.save_gif_replay = False + # main_config.env.render_in_ui = False + main_config.env.collector_env_num = 1 main_config.env.evaluator_env_num = 1 main_config.env.n_evaluator_episode = 1 + create_config.env_manager.type = 'base' total_test_episodes = num_episodes_each_seed * len(seeds) returns_mean_seeds = [] returns_seeds = [] diff --git a/zoo/board_games/go/config/go_alphazero_sp_mode_config.py b/zoo/board_games/go/config/go_alphazero_sp_mode_config.py index dbbdc10b2..d06251c65 100644 --- a/zoo/board_games/go/config/go_alphazero_sp_mode_config.py +++ b/zoo/board_games/go/config/go_alphazero_sp_mode_config.py @@ -14,7 +14,7 @@ collector_env_num = 8 n_episode = 8 -evaluator_env_num = 2 +evaluator_env_num = 1 update_per_collect = 50 batch_size = 256 max_env_step = int(10e6) @@ -22,11 +22,16 @@ if board_size == 19: num_simulations = 800 elif board_size == 9: - num_simulations = 180 + # num_simulations = 180 + num_simulations = 50 elif board_size == 6: - num_simulations = 80 + # num_simulations = 80 + num_simulations = 50 # board_size = 6 +# komi = 4 +# # board_size = 9 +# # komi = 7.5 # collector_env_num = 1 # n_episode = 1 # evaluator_env_num = 1 @@ -45,9 +50,9 @@ board_size=board_size, komi=komi, use_katago_bot=True, - # katago_checkpoint_path="/Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", - katago_checkpoint_path="/mnt/nfs/puyuan/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", - device='cuda', + katago_checkpoint_path="/Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", + # katago_checkpoint_path="/mnt/nfs/puyuan/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", + ignore_pass_if_have_other_legal_actions=True, battle_mode='self_play_mode', bot_action_type='v0', prob_random_action_in_bot=0, @@ -66,8 +71,6 @@ action_space_size=int(board_size * board_size + 1), num_res_blocks=1, num_channels=64, - # TODO: - # num_channels=32, ), cuda=True, board_size=board_size, diff --git a/zoo/board_games/go/envs/go_env.py b/zoo/board_games/go/envs/go_env.py index bc840e65f..d0a17cabf 100644 --- a/zoo/board_games/go/envs/go_env.py +++ b/zoo/board_games/go/envs/go_env.py @@ -92,7 +92,7 @@ class GoEnv(BaseEnv): scale=True, ignore_pass_if_have_other_legal_actions=True, device='cpu', - katago_model=None, + katago_policy=None, ) @classmethod @@ -101,33 +101,6 @@ def default_config(cls: type) -> EasyDict: cfg.cfg_type = cls.__name__ + 'Dict' return cfg - @property - def current_player(self): - return self._current_player - - @property - def current_player_index(self): - """ - current_player_index = 0, current_player = 1 - current_player_index = 1, current_player = 2 - """ - return 0 if self._current_player == 1 else 1 - - @property - def to_play(self): - """ - current_player_index = 0, current_player = 1, to_play = 2 - current_player_index = 1, current_player = 2, to_play = 1 - """ - return self.players[0] if self.current_player == self.players[1] else self.players[1] - - @property - def current_player_to_compute_bot_action(self): - """ - Overview: to compute expert action easily. - """ - return -1 if self.current_player == 1 else 1 - def __init__(self, cfg=None): # board_size: a int, representing the board size (board has a board_size x board_size shape) @@ -178,8 +151,8 @@ def __init__(self, cfg=None): self.render_in_ui = cfg.render_in_ui self.katago_checkpoint_path= cfg.katago_checkpoint_path self.ignore_pass_if_have_other_legal_actions = cfg.ignore_pass_if_have_other_legal_actions - self.device = cfg.device - self.katago_policy = cfg.katago_model + # self.device = cfg.device + self.katago_policy = cfg.katago_policy # self.katago_policy = KatagoPolicy(checkpoint_path=self.katago_checkpoint_path, board_size=self.board_size, # ignore_pass_if_have_other_legal_actions=self.ignore_pass_if_have_other_legal_actions, device=self.device) @@ -415,7 +388,10 @@ def step(self, action): # bot_action = self.human_to_action() bot_action = self.human_to_gtp_action() else: + s_time = time.time() bot_action = self.get_katago_action(to_play=2) + e_time = time.time() + print(f'katago_action time: {e_time - s_time}') if bot_action not in self.legal_actions: logging.warning( f"You input illegal *bot* action: {bot_action}, the legal_actions are {self.legal_actions}. " @@ -425,7 +401,7 @@ def step(self, action): # ****** update katago internal game state ****** # TODO(pu): how to avoid this? katago_flatten_action = self.lz_flatten_to_katago_flatten(bot_action, self.board_size) - # print('player 2:', str_coord(katago_flatten_action, self.katago_game_state.board)) + print('player 2 (katago):', str_coord(katago_flatten_action, self.katago_game_state.board)) self.update_katago_internal_game_state(katago_flatten_action, to_play=2) timestep_player2 = self._player_step(bot_action) @@ -461,6 +437,9 @@ def update_katago_internal_game_state(self, katago_flatten_action, to_play): command = ['play', 'w', gtp_action] self.katago_policy.katago_command(self.katago_game_state, command, to_play) + # ============================================================== + # katago related + # ============================================================== def get_katago_action(self, to_play): command = ['get_katago_action'] # self.current_player is the player who will play @@ -589,14 +568,6 @@ def current_state(self): # e.g. (6, 6, 17) - > (17, 6, 6) return np.transpose(raw_obs, [2, 0, 1]), np.transpose(raw_obs, [2, 0, 1]) - @property - def legal_actions(self): - return to_list(self.legal_moves()) - - @property - def board(self): - return self._raw_env._go.board - def legal_moves(self): if self._raw_env._go.is_game_over(): self.terminations = self._convert_to_dict( @@ -744,6 +715,10 @@ def gtp_action_to_flatten_action(self, gtp_action, board_size): flatten_action = (board_size - 1 - row) * board_size + col return flatten_action + # ============================================================== + # render related + # ============================================================== + def render_and_capture_frame(self, mode='only_save_gif'): self.render(mode=mode) self.capture_frame() @@ -840,21 +815,12 @@ def save_gif(self, output_file, duration=20): imageio.mimsave(output_file, self.frames, format="GIF", duration=duration) print("Gif saved to {}".format(output_file)) - def _check_bounds(self, c): - return 0 <= c[0] < self.board_size and 0 <= c[1] < self.board_size - def _encode_player_plane(self, agent): if agent == self.possible_agents[0]: return np.zeros([self.board_size, self.board_size], dtype=bool) else: return np.ones([self.board_size, self.board_size], dtype=bool) - def _int_to_name(self, ind): - return self.possible_agents[ind] - - def _name_to_int(self, name): - return self.possible_agents.index(name) - def _convert_to_dict(self, list_of_list): return dict(zip(self.possible_agents, list_of_list)) @@ -864,18 +830,49 @@ def _encode_legal_actions(self, actions): def _encode_rewards(self, result): return [1, -1] if result == 1 else [-1, 1] - def set_game_result(self, result_val): - for i, name in enumerate(self.agents): - self.dones[name] = True - result_coef = 1 if i == 0 else -1 - self.rewards[name] = result_val * result_coef - self.infos[name] = {'legal_moves': []} - def seed(self, seed: int, dynamic_seed: bool = True) -> None: self._seed = seed self._dynamic_seed = dynamic_seed np.random.seed(self._seed) + @property + def current_player(self): + return self._current_player + + @property + def current_player_index(self): + """ + current_player_index = 0, current_player = 1 + current_player_index = 1, current_player = 2 + """ + return 0 if self._current_player == 1 else 1 + + @property + def to_play(self): + """ + current_player_index = 0, current_player = 1, to_play = 2 + current_player_index = 1, current_player = 2, to_play = 1 + """ + return self.players[0] if self.current_player == self.players[1] else self.players[1] + + @property + def current_player_to_compute_bot_action(self): + """ + Overview: to compute expert action easily. + """ + return -1 if self.current_player == 1 else 1 + + @current_player.setter + def current_player(self, value): + self._current_player = value + @property + def legal_actions(self): + return to_list(self.legal_moves()) + + @property + def board(self): + return self._raw_env._go.board + @property def observation_space(self) -> gym.spaces.Space: return self._observation_space @@ -888,10 +885,6 @@ def action_space(self) -> gym.spaces.Space: def reward_space(self) -> gym.spaces.Space: return self._reward_space - @current_player.setter - def current_player(self, value): - self._current_player = value - @staticmethod def create_collector_env_cfg(cfg: dict) -> List[dict]: collector_env_num = cfg.pop('collector_env_num') diff --git a/zoo/board_games/go/envs/katago_policy.py b/zoo/board_games/go/envs/katago_policy.py index 1684d6af0..71b748f33 100644 --- a/zoo/board_games/go/envs/katago_policy.py +++ b/zoo/board_games/go/envs/katago_policy.py @@ -1,42 +1,33 @@ """Adapted from https://github.com/lightvector/KataGo/blob/master/python/play.py""" +import colorsys +import logging +import math # !/usr/bin/python3 import os +import re import sys -# 将 Katago 项目的路径添加到 sys.path 中 -# sys.path.append(os.path.abspath('/Users/puyuan/code/KataGo/')) -# sys.path.append(os.path.abspath('/Users/puyuan/code/KataGo/python')) -sys.path.append(os.path.abspath('/mnt/nfs/puyuan/KataGo/')) -sys.path.append(os.path.abspath('/mnt/nfs/puyuan/KataGo/python')) - -import argparse -import math -import re -import logging -import colorsys import numpy as np - import torch import torch.nn +# 将 Katago 项目的路径添加到 sys.path 中 +try: + sys.path.append(os.path.abspath('/Users/puyuan/code/KataGo/python')) +except: + sys.path.append(os.path.abspath('/mnt/nfs/puyuan/KataGo/python')) + from board import Board from features import Features from model_pytorch import EXTRA_SCORE_DISTR_RADIUS from load_model import load_model -import sys description = """ Play go with a trained neural net! Implements a basic GTP engine that uses the neural net directly to play moves. """ -# if __name__ == "__main__": -# parser = argparse.ArgumentParser(description=description) -# parser.add_argument('-checkpoint', help='Checkpoint to test', required=False) -# parser.add_argument('-use-swa', help='Use SWA model', action="store_true", required=False) -# -# args = vars(parser.parse_args()) # Basic parsing -------------------------------------------------------- colstr = 'ABCDEFGHJKLMNOPQRST' @@ -91,7 +82,7 @@ def katago_flatten_to_lz_flatten(loc, board): return board.size * board.size x = board.loc_x(loc) # left_to_right 0,1,2,...,board.size-1 y = board.loc_y(loc) # upper_to_bottom 0,1,2,...,board.size-1 - if y * board.size + x <0: + if y * board.size + x < 0: print('debug') return y * board.size + x # 11 -> (0,0) -> 0 @@ -332,9 +323,6 @@ def lerp(p, x0, x1, y0, y1): 'gfx/PassAlive/passalive', ] -# board_size = BOARD_SIZE -# -# gs = GameState(board_size) rules = { "koRule": "KO_POSITIONAL", @@ -353,22 +341,23 @@ def lerp(p, x0, x1, y0, y1): input_feature_command_lookup = dict() -class KatagoPolicy(): +class KatagoPolicy: def __init__(self, checkpoint_path="/Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", board_size=9, ignore_pass_if_have_other_legal_actions=False, device='cpu'): self.device = device - self.load_katago_model(checkpoint_path, board_size) + + self.load_katago_policy(checkpoint_path, board_size) for i in range(self.model.bin_input_shape[1]): self.add_input_feature_visualizations("input-" + str(i), i, normalization_div=1) - self.ignore_pass_if_have_other_legal_actions= ignore_pass_if_have_other_legal_actions - def load_katago_model(self, + self.ignore_pass_if_have_other_legal_actions = ignore_pass_if_have_other_legal_actions + + def load_katago_policy(self, checkpoint_path="/Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", board_size=9): args = {} args["use_swa"] = False - # TODO(pu) # download form https://media.katagotraining.org/uploaded/networks/zips/kata1/kata1-b18c384nbt-s6582191360-d3422816034.zip # unzip to /Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034 @@ -376,16 +365,10 @@ def load_katago_model(self, checkpoint_file = args["checkpoint"] use_swa = args["use_swa"] - - BOARD_SIZE = board_size - - # print(args) - # Hardcoded max board size self.pos_len = 19 # Model ---------------------------------------------------------------- - logging.root.handlers = [] logging.basicConfig( level=logging.INFO, @@ -398,7 +381,8 @@ def load_katago_model(self, torch.set_printoptions(precision=7, sci_mode=False, linewidth=100000, edgeitems=1000, threshold=1000000) # model, swa_model, _ = load_model(checkpoint_file, use_swa, device="cpu", pos_len=self.pos_len, verbose=True) - model, swa_model, _ = load_model(checkpoint_file, use_swa, device=self.device, pos_len=self.pos_len, verbose=True) + model, swa_model, _ = load_model(checkpoint_file, use_swa, device=self.device, pos_len=self.pos_len, + verbose=True) model.eval() model_config = model.config @@ -409,6 +393,247 @@ def load_katago_model(self, self.features = Features(model_config, self.pos_len) self.model = model + def katago_command(self, game_state, command, to_play=None): + """ + command = ['play', 'b', 'a4'] + command = ['play', 'w', 'a4'] + command = ['genmove', 'w', 'a4'] + command = ['get_katago_action'] + command = ['boardsize', 9] + command = ["showboard"] + """ + gs = game_state + if re.match('\d+', command[0]): + cmdid = command[0] + command = command[1:] + else: + cmdid = '' + + ret = '' + if command[0] == "showboard": + ret = "\n" + gs.board.to_string().strip() + elif command[0] == "komi": + rules["whiteKomi"] = float(command[1]) + elif command[0] == "play": + pla = (Board.BLACK if command[1] == "B" or command[1] == "b" else Board.WHITE) + loc = parse_coord(command[2], gs.board) + gs.board.play(pla, loc) + gs.moves.append((pla, loc)) + gs.boards.append(gs.board.copy()) + return gs + elif command[0] == "genmove": + outputs = self.get_outputs(gs, rules) + loc = outputs["genmove_result"] + pla = gs.board.pla + + if len(command) > 1: + pla = (Board.BLACK if command[1] == "B" or command[1] == "b" else Board.WHITE) + gs.board.play(pla, loc) + gs.moves.append((pla, loc)) + gs.boards.append(gs.board.copy()) + ret = str_coord(loc, gs.board) + + elif command[0] == "get_katago_action": + # NOTE: here bot action may be illegal action in go_lightzero + outputs = self.get_outputs(gs, rules) + if to_play == 1: + moves_and_probs0 = outputs["moves_and_probs0"] + moves_and_probs = sorted(moves_and_probs0, key=lambda moveandprob: moveandprob[1], reverse=True) + katago_flatten_action = moves_and_probs[0][0] + if self.ignore_pass_if_have_other_legal_actions and len(moves_and_probs) > 1: + if katago_flatten_action == Board.PASS_LOC: # 0 + katago_flatten_action = moves_and_probs[1][0] + # TODO + # print('ignore_pass_if_have_other_legal_actions now!') + elif to_play == 2: + moves_and_probs1 = outputs["moves_and_probs1"] + moves_and_probs = sorted(moves_and_probs1, key=lambda moveandprob: moveandprob[1], reverse=True) + katago_flatten_action = moves_and_probs[0][0] # moves_and_probs[0]: (katago_flatten_action, prior) + if self.ignore_pass_if_have_other_legal_actions and len(moves_and_probs) > 1: + if katago_flatten_action == Board.PASS_LOC: # 0 + katago_flatten_action = moves_and_probs[1][0] + # print('ignore_pass_if_have_other_legal_actions now!') + + # gtp_action = str_coord(katago_flatten_action, gs.board) + lz_flatten_action = katago_flatten_to_lz_flatten(katago_flatten_action, gs.board) + return lz_flatten_action + + elif command[0] == "name": + ret = 'KataGo Raw Neural Net Debug/Test Script' + elif command[0] == "version": + ret = '1.0' + elif command[0] == "list_commands": + ret = '\n'.join(known_commands) + elif command[0] == "known_command": + ret = 'true' if command[1] in known_commands else 'false' + elif command[0] == "gogui-analyze_commands": + ret = '\n'.join(known_analyze_commands) + elif command[0] == "setrule": + ret = "" + if command[1] == "korule": + rules["koRule"] = command[2].upper() + elif command[1] == "scoringrule": + rules["scoringRule"] = command[2].upper() + elif command[1] == "taxrule": + rules["taxRule"] = command[2].upper() + elif command[1] == "multistonesuicidelegal": + rules["multiStoneSuicideLegal"] = (command[2].lower() == "true") + elif command[1] == "hasbutton": + rules["hasButton"] = (command[2].lower() == "true") + elif command[1] == "encorephase": + rules["encorePhase"] = int(command[2]) + elif command[1] == "passwouldendphase": + rules["passWouldEndPhase"] = (command[2].lower() == "true") + elif command[1] == "whitekomi" or command[1] == "komi": + rules["whiteKomi"] = float(command[2]) + elif command[1] == "asym": + rules["asymPowersOfTwo"] = float(command[2]) + else: + ret = "Unknown rules setting" + elif command[0] == "policy": + outputs = self.get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["moves_and_probs0"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=outputs) + ret = "\n".join(gfx_commands) + elif command[0] == "policy1": + outputs = self.get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["moves_and_probs1"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=outputs) + ret = "\n".join(gfx_commands) + elif command[0] == "logpolicy": + outputs = self.get_outputs(gs, rules) + moves_and_logprobs = [(move, max(0.0, 4.9 + math.log10(prob))) for (move, prob) in + outputs["moves_and_probs0"]] + gfx_commands = get_gfx_commands_for_heatmap(moves_and_logprobs, gs.board, normalization_div=6, + is_percent=False, + value_and_score_from=outputs) + ret = "\n".join(gfx_commands) + elif command[0] == "ownership": + outputs = self.get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["ownership_by_loc"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=None, hotcold=True) + ret = "\n".join(gfx_commands) + elif command[0] == "scoring": + outputs = self.get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["scoring_by_loc"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=None, hotcold=True) + ret = "\n".join(gfx_commands) + elif command[0] == "futurepos0": + outputs = self.get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["futurepos0_by_loc"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=None, hotcold=True) + ret = "\n".join(gfx_commands) + elif command[0] == "futurepos1": + outputs = self.get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["futurepos1_by_loc"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=None, hotcold=True) + ret = "\n".join(gfx_commands) + elif command[0] == "seki": + outputs = self.get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["seki_by_loc"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=None) + ret = "\n".join(gfx_commands) + elif command[0] == "seki2": + outputs = self.get_outputs(gs, rules) + gfx_commands = get_gfx_commands_for_heatmap(outputs["seki_by_loc2"], gs.board, normalization_div=None, + is_percent=True, value_and_score_from=None) + ret = "\n".join(gfx_commands) + + elif command[0] == "policy_raw": + outputs = self.get_outputs(gs, rules) + ret = "\n" + policysum = 0.0 + for y in range(gs.board.size): + for x in range(gs.board.size): + loc = gs.board.loc(x, y) + pos = self.features.loc_to_tensor_pos(loc, gs.board) + gs.board.would_be_legal(gs.board.pla, loc) + policysum += outputs["policy0"][pos] + loc = Board.PASS_LOC + pos = self.features.loc_to_tensor_pos(loc, gs.board) + policysum += outputs["policy0"][pos] + + for y in range(gs.board.size): + for x in range(gs.board.size): + loc = gs.board.loc(x, y) + pos = self.features.loc_to_tensor_pos(loc, gs.board) + if gs.board.would_be_legal(gs.board.pla, loc): + ret += "%6.3f" % (100.0 * outputs["policy0"][pos] / policysum) + else: + ret += " - " + ret += " " + ret += "\n" + loc = Board.PASS_LOC + pos = self.features.loc_to_tensor_pos(loc, gs.board) + ret += "Pass: %6.3f" % (100.0 * outputs["policy0"][pos] / policysum) + + elif command[0] == "policy1_raw": + outputs = self.get_outputs(gs, rules) + ret = "\n" + + for y in range(gs.board.size): + for x in range(gs.board.size): + loc = gs.board.loc(x, y) + pos = self.features.loc_to_tensor_pos(loc, gs.board) + if gs.board.would_be_legal(gs.board.pla, loc): + ret += "%6.3f" % (100.0 * outputs["policy1"][pos]) + else: + ret += " - " + ret += " " + ret += "\n" + loc = Board.PASS_LOC + pos = self.features.loc_to_tensor_pos(loc, gs.board) + ret += "Pass: %6.3f" % (100.0 * outputs["policy1"][pos]) + + elif command[0] == "ownership_raw": + outputs = self.get_outputs(gs, rules) + ret = self.get_board_matrix_str(outputs["ownership"], 100.0, "%+7.3f") + elif command[0] == "scoring_raw": + outputs = self.get_outputs(gs, rules) + ret = self.get_board_matrix_str(outputs["scoring"], 100.0, "%+7.3f") + elif command[0] == "futurepos0_raw": + outputs = self.get_outputs(gs, rules) + ret = self.get_board_matrix_str(outputs["futurepos"][0], 100.0, "%+7.3f") + elif command[0] == "futurepos1_raw": + outputs = self.get_outputs(gs, rules) + ret = self.get_board_matrix_str(outputs["futurepos"][1], 100.0, "%+7.3f") + elif command[0] == "seki_raw": + outputs = self.get_outputs(gs, rules) + ret = self.get_board_matrix_str(outputs["seki"], 100.0, "%+7.3f") + elif command[0] == "seki2_raw": + outputs = self.get_outputs(gs, rules) + ret = self.get_board_matrix_str(outputs["seki2"], 100.0, "%+7.3f") + + elif command[0] in input_feature_command_lookup: + (feature_idx, normalization_div) = input_feature_command_lookup[command[0]] + locs_and_values = self.get_input_feature(gs, rules, feature_idx) + gfx_commands = get_gfx_commands_for_heatmap(locs_and_values, gs.board, normalization_div, is_percent=False) + ret = "\n".join(gfx_commands) + + elif command[0] == "passalive": + locs_and_values = get_pass_alive(gs.board, rules) + gfx_commands = get_gfx_commands_for_heatmap(locs_and_values, gs.board, normalization_div=None, + is_percent=False) + ret = "\n".join(gfx_commands) + + elif command[0] == "scorebelief": + outputs = self.get_outputs(gs, rules) + ret = self.print_scorebelief(gs, outputs) + + elif command[0] == "protocol_version": + ret = '2' + elif command[0] == "quit": + print('=%s \n\n' % (cmdid,), end='') + else: + print('Warning: Ignoring unknown command - %s' % (line,), file=sys.stderr) + ret = None + + if ret is not None: + print('=%s %s\n\n' % (cmdid, ret,), end='') + else: + print('?%s ???\n\n' % (cmdid,), end='') + sys.stdout.flush() + def get_outputs(self, gs, rules): with torch.no_grad(): self.model.eval() @@ -431,8 +656,8 @@ def get_outputs(self, gs, rules): # self.model_outputs = self.model(apply_symmetry(batch["binaryInputNCHW"],symmetry),batch["globalInputNC"]) model_outputs = self.model( - torch.tensor(bin_input_data, dtype=torch.float32), - torch.tensor(global_input_data, dtype=torch.float32), + torch.tensor(bin_input_data, dtype=torch.float32, device=self.device), + torch.tensor(global_input_data, dtype=torch.float32, device=self.device), ) outputs = self.model.postprocess_output(model_outputs) ( @@ -713,243 +938,3 @@ def get_board_matrix_str(self, matrix, scale, formatstr): ret += "\n" return ret - def katago_command(self, game_state, command, to_play=None): - """ - command = ['play', 'b', 'a4'] - command = ['play', 'w', 'a4'] - command = ['genmove', 'w', 'a4'] - command = ['get_katago_action'] - command = ['boardsize', 9] - command = ["showboard"] - """ - gs = game_state - if re.match('\d+', command[0]): - cmdid = command[0] - command = command[1:] - else: - cmdid = '' - - ret = '' - if command[0] == "showboard": - ret = "\n" + gs.board.to_string().strip() - elif command[0] == "komi": - rules["whiteKomi"] = float(command[1]) - elif command[0] == "play": - pla = (Board.BLACK if command[1] == "B" or command[1] == "b" else Board.WHITE) - loc = parse_coord(command[2], gs.board) - gs.board.play(pla, loc) - gs.moves.append((pla, loc)) - gs.boards.append(gs.board.copy()) - return gs - elif command[0] == "genmove": - outputs = self.get_outputs(gs, rules) - loc = outputs["genmove_result"] - pla = gs.board.pla - - if len(command) > 1: - pla = (Board.BLACK if command[1] == "B" or command[1] == "b" else Board.WHITE) - gs.board.play(pla, loc) - gs.moves.append((pla, loc)) - gs.boards.append(gs.board.copy()) - ret = str_coord(loc, gs.board) - - elif command[0] == "get_katago_action": - # NOTE: here bot action may be illegal action in go_lightzero - outputs = self.get_outputs(gs, rules) - if to_play == 1: - moves_and_probs0 = outputs["moves_and_probs0"] - moves_and_probs = sorted(moves_and_probs0, key=lambda moveandprob: moveandprob[1], reverse=True) - katago_flatten_action = moves_and_probs[0][0] - if self.ignore_pass_if_have_other_legal_actions and len(moves_and_probs) > 1: - if katago_flatten_action == Board.PASS_LOC: # 0 - katago_flatten_action = moves_and_probs[1][0] - # TODO - # print('ignore_pass_if_have_other_legal_actions now!') - elif to_play == 2: - moves_and_probs1 = outputs["moves_and_probs1"] - moves_and_probs = sorted(moves_and_probs1, key=lambda moveandprob: moveandprob[1], reverse=True) - katago_flatten_action = moves_and_probs[0][0] # moves_and_probs[0]: (katago_flatten_action, prior) - if self.ignore_pass_if_have_other_legal_actions and len(moves_and_probs)>1: - if katago_flatten_action == Board.PASS_LOC: # 0 - katago_flatten_action = moves_and_probs[1][0] - # print('ignore_pass_if_have_other_legal_actions now!') - - # gtp_action = str_coord(katago_flatten_action, gs.board) - lz_flatten_action = katago_flatten_to_lz_flatten(katago_flatten_action, gs.board) - return lz_flatten_action - - elif command[0] == "name": - ret = 'KataGo Raw Neural Net Debug/Test Script' - elif command[0] == "version": - ret = '1.0' - elif command[0] == "list_commands": - ret = '\n'.join(known_commands) - elif command[0] == "known_command": - ret = 'true' if command[1] in known_commands else 'false' - elif command[0] == "gogui-analyze_commands": - ret = '\n'.join(known_analyze_commands) - elif command[0] == "setrule": - ret = "" - if command[1] == "korule": - rules["koRule"] = command[2].upper() - elif command[1] == "scoringrule": - rules["scoringRule"] = command[2].upper() - elif command[1] == "taxrule": - rules["taxRule"] = command[2].upper() - elif command[1] == "multistonesuicidelegal": - rules["multiStoneSuicideLegal"] = (command[2].lower() == "true") - elif command[1] == "hasbutton": - rules["hasButton"] = (command[2].lower() == "true") - elif command[1] == "encorephase": - rules["encorePhase"] = int(command[2]) - elif command[1] == "passwouldendphase": - rules["passWouldEndPhase"] = (command[2].lower() == "true") - elif command[1] == "whitekomi" or command[1] == "komi": - rules["whiteKomi"] = float(command[2]) - elif command[1] == "asym": - rules["asymPowersOfTwo"] = float(command[2]) - else: - ret = "Unknown rules setting" - elif command[0] == "policy": - outputs = self.get_outputs(gs, rules) - gfx_commands = get_gfx_commands_for_heatmap(outputs["moves_and_probs0"], gs.board, normalization_div=None, - is_percent=True, value_and_score_from=outputs) - ret = "\n".join(gfx_commands) - elif command[0] == "policy1": - outputs = self.get_outputs(gs, rules) - gfx_commands = get_gfx_commands_for_heatmap(outputs["moves_and_probs1"], gs.board, normalization_div=None, - is_percent=True, value_and_score_from=outputs) - ret = "\n".join(gfx_commands) - elif command[0] == "logpolicy": - outputs = self.get_outputs(gs, rules) - moves_and_logprobs = [(move, max(0.0, 4.9 + math.log10(prob))) for (move, prob) in - outputs["moves_and_probs0"]] - gfx_commands = get_gfx_commands_for_heatmap(moves_and_logprobs, gs.board, normalization_div=6, - is_percent=False, - value_and_score_from=outputs) - ret = "\n".join(gfx_commands) - elif command[0] == "ownership": - outputs = self.get_outputs(gs, rules) - gfx_commands = get_gfx_commands_for_heatmap(outputs["ownership_by_loc"], gs.board, normalization_div=None, - is_percent=True, value_and_score_from=None, hotcold=True) - ret = "\n".join(gfx_commands) - elif command[0] == "scoring": - outputs = self.get_outputs(gs, rules) - gfx_commands = get_gfx_commands_for_heatmap(outputs["scoring_by_loc"], gs.board, normalization_div=None, - is_percent=True, value_and_score_from=None, hotcold=True) - ret = "\n".join(gfx_commands) - elif command[0] == "futurepos0": - outputs = self.get_outputs(gs, rules) - gfx_commands = get_gfx_commands_for_heatmap(outputs["futurepos0_by_loc"], gs.board, normalization_div=None, - is_percent=True, value_and_score_from=None, hotcold=True) - ret = "\n".join(gfx_commands) - elif command[0] == "futurepos1": - outputs = self.get_outputs(gs, rules) - gfx_commands = get_gfx_commands_for_heatmap(outputs["futurepos1_by_loc"], gs.board, normalization_div=None, - is_percent=True, value_and_score_from=None, hotcold=True) - ret = "\n".join(gfx_commands) - elif command[0] == "seki": - outputs = self.get_outputs(gs, rules) - gfx_commands = get_gfx_commands_for_heatmap(outputs["seki_by_loc"], gs.board, normalization_div=None, - is_percent=True, value_and_score_from=None) - ret = "\n".join(gfx_commands) - elif command[0] == "seki2": - outputs = self.get_outputs(gs, rules) - gfx_commands = get_gfx_commands_for_heatmap(outputs["seki_by_loc2"], gs.board, normalization_div=None, - is_percent=True, value_and_score_from=None) - ret = "\n".join(gfx_commands) - - elif command[0] == "policy_raw": - outputs = self.get_outputs(gs, rules) - ret = "\n" - policysum = 0.0 - for y in range(gs.board.size): - for x in range(gs.board.size): - loc = gs.board.loc(x, y) - pos = self.features.loc_to_tensor_pos(loc, gs.board) - gs.board.would_be_legal(gs.board.pla, loc) - policysum += outputs["policy0"][pos] - loc = Board.PASS_LOC - pos = self.features.loc_to_tensor_pos(loc, gs.board) - policysum += outputs["policy0"][pos] - - for y in range(gs.board.size): - for x in range(gs.board.size): - loc = gs.board.loc(x, y) - pos = self.features.loc_to_tensor_pos(loc, gs.board) - if gs.board.would_be_legal(gs.board.pla, loc): - ret += "%6.3f" % (100.0 * outputs["policy0"][pos] / policysum) - else: - ret += " - " - ret += " " - ret += "\n" - loc = Board.PASS_LOC - pos = self.features.loc_to_tensor_pos(loc, gs.board) - ret += "Pass: %6.3f" % (100.0 * outputs["policy0"][pos] / policysum) - - elif command[0] == "policy1_raw": - outputs = self.get_outputs(gs, rules) - ret = "\n" - - for y in range(gs.board.size): - for x in range(gs.board.size): - loc = gs.board.loc(x, y) - pos = self.features.loc_to_tensor_pos(loc, gs.board) - if gs.board.would_be_legal(gs.board.pla, loc): - ret += "%6.3f" % (100.0 * outputs["policy1"][pos]) - else: - ret += " - " - ret += " " - ret += "\n" - loc = Board.PASS_LOC - pos = self.features.loc_to_tensor_pos(loc, gs.board) - ret += "Pass: %6.3f" % (100.0 * outputs["policy1"][pos]) - - elif command[0] == "ownership_raw": - outputs = self.get_outputs(gs, rules) - ret = self.get_board_matrix_str(outputs["ownership"], 100.0, "%+7.3f") - elif command[0] == "scoring_raw": - outputs = self.get_outputs(gs, rules) - ret = self.get_board_matrix_str(outputs["scoring"], 100.0, "%+7.3f") - elif command[0] == "futurepos0_raw": - outputs = self.get_outputs(gs, rules) - ret = self.get_board_matrix_str(outputs["futurepos"][0], 100.0, "%+7.3f") - elif command[0] == "futurepos1_raw": - outputs = self.get_outputs(gs, rules) - ret = self.get_board_matrix_str(outputs["futurepos"][1], 100.0, "%+7.3f") - elif command[0] == "seki_raw": - outputs = self.get_outputs(gs, rules) - ret = self.get_board_matrix_str(outputs["seki"], 100.0, "%+7.3f") - elif command[0] == "seki2_raw": - outputs = self.get_outputs(gs, rules) - ret = self.get_board_matrix_str(outputs["seki2"], 100.0, "%+7.3f") - - elif command[0] in input_feature_command_lookup: - (feature_idx, normalization_div) = input_feature_command_lookup[command[0]] - locs_and_values = self.get_input_feature(gs, rules, feature_idx) - gfx_commands = get_gfx_commands_for_heatmap(locs_and_values, gs.board, normalization_div, is_percent=False) - ret = "\n".join(gfx_commands) - - elif command[0] == "passalive": - locs_and_values = get_pass_alive(gs.board, rules) - gfx_commands = get_gfx_commands_for_heatmap(locs_and_values, gs.board, normalization_div=None, - is_percent=False) - ret = "\n".join(gfx_commands) - - elif command[0] == "scorebelief": - outputs = self.get_outputs(gs, rules) - ret = self.print_scorebelief(gs, outputs) - - elif command[0] == "protocol_version": - ret = '2' - elif command[0] == "quit": - print('=%s \n\n' % (cmdid,), end='') - else: - print('Warning: Ignoring unknown command - %s' % (line,), file=sys.stderr) - ret = None - - if ret is not None: - print('=%s %s\n\n' % (cmdid, ret,), end='') - else: - print('?%s ???\n\n' % (cmdid,), end='') - sys.stdout.flush() diff --git a/zoo/board_games/go/envs/test_katago_bot.py b/zoo/board_games/go/envs/test_katago_bot.py index 72399390a..ce824714e 100644 --- a/zoo/board_games/go/envs/test_katago_bot.py +++ b/zoo/board_games/go/envs/test_katago_bot.py @@ -5,11 +5,12 @@ from easydict import EasyDict from zoo.board_games.go.envs.go_env import GoEnv, flatten_action_to_gtp_action -from zoo.board_games.go.envs.katago_policy import str_coord +from zoo.board_games.go.envs.katago_policy import str_coord, KatagoPolicy + cfg = EasyDict( - board_size=19, + # board_size=19, # board_size=9, - # board_size=6, + board_size=5, save_gif_replay=True, render_in_ui=True, # save_gif_replay=False, @@ -18,7 +19,6 @@ ignore_pass_if_have_other_legal_actions=True, save_gif_path='./', komi=7.5, - # komi=7, battle_mode='self_play_mode', prob_random_agent=0, channel_last=False, @@ -28,8 +28,13 @@ prob_random_action_in_bot=0., check_action_to_connect4_in_bot_v0=False, stop_value=1, + katago_device='cpu', ) +cfg.katago_policy = KatagoPolicy(checkpoint_path=cfg.katago_checkpoint_path, board_size=cfg.board_size, + ignore_pass_if_have_other_legal_actions=cfg.ignore_pass_if_have_other_legal_actions, + device=cfg.katago_device) + @pytest.mark.envtest class TestKataGoBot: @@ -37,10 +42,11 @@ class TestKataGoBot: def test_katago_bot(self): env = GoEnv(cfg) - test_episodes = 1 + test_episodes = 2 for i in range(test_episodes): + print('=' * 20) print(f'episode {i}') - print('='*20) + print('=' * 20) obs = env.reset() # print(obs['observation'].shape, obs['action_mask'].shape) @@ -123,4 +129,4 @@ def test_katago_bot(self): print('draw') break -# TestKataGoBot().test_katago_bot() \ No newline at end of file +# TestKataGoBot().test_katago_bot() From 2349e28005cd4ef012d63fff89caaea269182d21 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Thu, 6 Jul 2023 18:54:54 +0800 Subject: [PATCH 21/34] polish katago python import --- .../go/config/go_alphazero_sp_mode_config.py | 4 +-- zoo/board_games/go/envs/katago_policy.py | 29 +++++++++++++++---- 2 files changed, 26 insertions(+), 7 deletions(-) diff --git a/zoo/board_games/go/config/go_alphazero_sp_mode_config.py b/zoo/board_games/go/config/go_alphazero_sp_mode_config.py index d06251c65..74bd3707c 100644 --- a/zoo/board_games/go/config/go_alphazero_sp_mode_config.py +++ b/zoo/board_games/go/config/go_alphazero_sp_mode_config.py @@ -4,8 +4,8 @@ # ============================================================== # begin of the most frequently changed config specified by the user # ============================================================== -board_size = 6 -# board_size = 9 +# board_size = 6 +board_size = 9 if board_size in [9, 19]: komi = 7.5 diff --git a/zoo/board_games/go/envs/katago_policy.py b/zoo/board_games/go/envs/katago_policy.py index 71b748f33..91020a3e0 100644 --- a/zoo/board_games/go/envs/katago_policy.py +++ b/zoo/board_games/go/envs/katago_policy.py @@ -13,10 +13,29 @@ import torch.nn # 将 Katago 项目的路径添加到 sys.path 中 -try: - sys.path.append(os.path.abspath('/Users/puyuan/code/KataGo/python')) -except: - sys.path.append(os.path.abspath('/mnt/nfs/puyuan/KataGo/python')) +def add_katago_paths(): + user_paths = [ + os.path.abspath('/Users/puyuan/code/KataGo/'), + os.path.abspath('/Users/puyuan/code/KataGo/python') + ] + server_paths = [ + os.path.abspath('/mnt/nfs/puyuan/KataGo/'), + os.path.abspath('/mnt/nfs/puyuan/KataGo/python') + ] + + # Check if user paths exist, otherwise use server paths + if os.path.exists(user_paths[0]): + paths_to_add = user_paths + else: + paths_to_add = server_paths + + for path in paths_to_add: + if path not in sys.path: + sys.path.append(path) + + +# Call the function to add KataGo paths +add_katago_paths() from board import Board from features import Features @@ -634,7 +653,7 @@ def katago_command(self, game_state, command, to_play=None): print('?%s ???\n\n' % (cmdid,), end='') sys.stdout.flush() - def get_outputs(self, gs, rules): + def get_outgiputs(self, gs, rules): with torch.no_grad(): self.model.eval() From d6083e4ac27bd7f33a3cc6670e615401e302ebc1 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Thu, 20 Jul 2023 19:32:20 +0800 Subject: [PATCH 22/34] feature(pu): add alphazero ctree init version --- .gitignore | 4 +- .gitmodules | 3 + lzero/mcts/ctree/alphazero/cmake_example | 1 + .../alphazero/ctree_alphazero/CMakeLists.txt | 24 ++ .../ctree_alphazero/CMakeLists_mcts.txt | 23 ++ .../ctree_alphazero/CMakeLists_node.txt | 23 ++ .../ctree_alphazero/test_mcts_alphazero.py | 28 +++ .../ctree_alphazero/test_node_alphazero.py | 8 + .../test_node_alphazero_bkp.py | 7 + .../alphazero/cython_alphazero/node.pyx.bkp | 68 ++++++ .../alphazero/pybind11_test/CMakeLists.txt | 24 ++ .../pybind11_test/test_pybind11_example.py | 5 + .../ctree_sampled_efficientzero/ezs_tree.pyx | 6 +- lzero/mcts/ptree/ptree_az_cnode.py | 230 ++++++++++++++++++ lzero/policy/alphazero.py | 57 ++++- zoo/board_games/go/envs/katago_policy.py | 2 +- zoo/board_games/go/envs/test_go_mcts_bot.py | 82 ++++--- .../tictactoe_alphazero_sp_mode_config.py | 1 + .../tictactoe/envs/tictactoe_env.py | 5 + .../cartpole/config/cartpole_muzero_config.py | 1 + 20 files changed, 555 insertions(+), 47 deletions(-) create mode 100644 .gitmodules create mode 160000 lzero/mcts/ctree/alphazero/cmake_example create mode 100644 lzero/mcts/ctree/alphazero/ctree_alphazero/CMakeLists.txt create mode 100644 lzero/mcts/ctree/alphazero/ctree_alphazero/CMakeLists_mcts.txt create mode 100644 lzero/mcts/ctree/alphazero/ctree_alphazero/CMakeLists_node.txt create mode 100644 lzero/mcts/ctree/alphazero/ctree_alphazero/test_mcts_alphazero.py create mode 100644 lzero/mcts/ctree/alphazero/ctree_alphazero/test_node_alphazero.py create mode 100644 lzero/mcts/ctree/alphazero/ctree_alphazero/test_node_alphazero_bkp.py create mode 100644 lzero/mcts/ctree/alphazero/cython_alphazero/node.pyx.bkp create mode 100644 lzero/mcts/ctree/alphazero/pybind11_test/CMakeLists.txt create mode 100644 lzero/mcts/ctree/alphazero/pybind11_test/test_pybind11_example.py create mode 100644 lzero/mcts/ptree/ptree_az_cnode.py diff --git a/.gitignore b/.gitignore index c164950f6..b476a3777 100644 --- a/.gitignore +++ b/.gitignore @@ -1444,4 +1444,6 @@ events.* !/lzero/mcts/**/lib/*.h **/tb/* **/mcts/ctree/tests_cpp/* -**/*tmp* \ No newline at end of file +**/*tmp* + +/lzero/mcts/**/pybind11/* \ No newline at end of file diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 000000000..0f9f6e26c --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "lzero/mcts/ctree/ctree_alphazero/pybind11"] + path = lzero/mcts/ctree/ctree_alphazero/pybind11 + url = https://github.com/pybind/pybind11.git diff --git a/lzero/mcts/ctree/alphazero/cmake_example b/lzero/mcts/ctree/alphazero/cmake_example new file mode 160000 index 000000000..fc9fd1cf1 --- /dev/null +++ b/lzero/mcts/ctree/alphazero/cmake_example @@ -0,0 +1 @@ +Subproject commit fc9fd1cf1d8d13ca8675adf8371957ee49790e72 diff --git a/lzero/mcts/ctree/alphazero/ctree_alphazero/CMakeLists.txt b/lzero/mcts/ctree/alphazero/ctree_alphazero/CMakeLists.txt new file mode 100644 index 000000000..38fa58eff --- /dev/null +++ b/lzero/mcts/ctree/alphazero/ctree_alphazero/CMakeLists.txt @@ -0,0 +1,24 @@ +# cmake_minimum_required(VERSION 2.8.12) +cmake_minimum_required(VERSION 3.4...3.18) + +# cmake_policy(SET CMP0048 NEW) +project(mcts_alphazero VERSION 1.0) + +# 找到 Python +find_package(Python3 COMPONENTS Interpreter Development REQUIRED) + +add_subdirectory(pybind11) +# 在此处添加两个cpp文件 +pybind11_add_module(mcts_alphazero mcts_alphazero.cpp node_alphazero.cpp) + +# 将Python头文件路径添加到你的库的包含路径中 +target_include_directories(mcts_alphazero PRIVATE ${Python3_INCLUDE_DIRS}) + +# 链接你的库和 pybind11::module +target_link_libraries(mcts_alphazero PRIVATE pybind11::module) + +# 设置你的库的Python版本 +set_target_properties(mcts_alphazero PROPERTIES PYTHON_STANDARD ${Python3_VERSION}) + + +# CMakeLists.txt diff --git a/lzero/mcts/ctree/alphazero/ctree_alphazero/CMakeLists_mcts.txt b/lzero/mcts/ctree/alphazero/ctree_alphazero/CMakeLists_mcts.txt new file mode 100644 index 000000000..51ade3817 --- /dev/null +++ b/lzero/mcts/ctree/alphazero/ctree_alphazero/CMakeLists_mcts.txt @@ -0,0 +1,23 @@ +# cmake_minimum_required(VERSION 2.8.12) +cmake_minimum_required(VERSION 3.4...3.18) + +# cmake_policy(SET CMP0048 NEW) +project(mcts_alphazero VERSION 1.0) + +# 找到 Python +find_package(Python3 COMPONENTS Interpreter Development REQUIRED) + +add_subdirectory(pybind11) +pybind11_add_module(mcts_alphazero mcts_alphazero.cpp) + +# 将Python头文件路径添加到你的库的包含路径中 +target_include_directories(mcts_alphazero PRIVATE ${Python3_INCLUDE_DIRS}) + +# 链接你的库和 pybind11::module +target_link_libraries(mcts_alphazero PRIVATE pybind11::module) + +# 设置你的库的Python版本 +set_target_properties(mcts_alphazero PROPERTIES PYTHON_STANDARD ${Python3_VERSION}) + + +# CMakeLists.txt diff --git a/lzero/mcts/ctree/alphazero/ctree_alphazero/CMakeLists_node.txt b/lzero/mcts/ctree/alphazero/ctree_alphazero/CMakeLists_node.txt new file mode 100644 index 000000000..6bef49def --- /dev/null +++ b/lzero/mcts/ctree/alphazero/ctree_alphazero/CMakeLists_node.txt @@ -0,0 +1,23 @@ +# cmake_minimum_required(VERSION 2.8.12) +cmake_minimum_required(VERSION 3.4...3.18) + +# cmake_policy(SET CMP0048 NEW) +project(node_alphazero VERSION 1.0) + +# 找到 Python +find_package(Python3 COMPONENTS Interpreter Development REQUIRED) + +add_subdirectory(pybind11) +pybind11_add_module(node_alphazero node_alphazero.cpp) + +# 将Python头文件路径添加到你的库的包含路径中 +target_include_directories(node_alphazero PRIVATE ${Python3_INCLUDE_DIRS}) + +# 链接你的库和 pybind11::module +target_link_libraries(node_alphazero PRIVATE pybind11::module) + +# 设置你的库的Python版本 +set_target_properties(node_alphazero PROPERTIES PYTHON_STANDARD ${Python3_VERSION}) + + +# CMakeLists.txt diff --git a/lzero/mcts/ctree/alphazero/ctree_alphazero/test_mcts_alphazero.py b/lzero/mcts/ctree/alphazero/ctree_alphazero/test_mcts_alphazero.py new file mode 100644 index 000000000..d8dda081a --- /dev/null +++ b/lzero/mcts/ctree/alphazero/ctree_alphazero/test_mcts_alphazero.py @@ -0,0 +1,28 @@ +import sys +sys.path.append('/Users/puyuan/code/LightZero/lzero/mcts/ctree/alphazero/ctree_alphazero/build') + +import mcts_alphazero +mcts_alphazero = mcts_alphazero.MCTS() + +def _policy_value_fn(self, env: 'Env') -> Tuple[Dict[int, np.ndarray], float]: # noqa + legal_actions = env.legal_actions + current_state, current_state_scale = env.current_state() + current_state_scale = torch.from_numpy(current_state_scale).to( + device=self._device, dtype=torch.float + ).unsqueeze(0) + with torch.no_grad(): + action_probs, value = self._policy_model.compute_prob_value(current_state_scale) + action_probs_dict = dict(zip(legal_actions, action_probs.squeeze(0)[legal_actions].detach().cpu().numpy())) + return action_probs_dict, value.item() + +action, mcts_probs = mcts_alphazero.get_next_action( + simulate_env=simulate_env, + policy_forward_fn=_policy_value_fn, + temperature=1, + sample=True, +) + +print(action, mcts_probs) + + + diff --git a/lzero/mcts/ctree/alphazero/ctree_alphazero/test_node_alphazero.py b/lzero/mcts/ctree/alphazero/ctree_alphazero/test_node_alphazero.py new file mode 100644 index 000000000..fdc7e28ee --- /dev/null +++ b/lzero/mcts/ctree/alphazero/ctree_alphazero/test_node_alphazero.py @@ -0,0 +1,8 @@ +import sys +sys.path.append('/Users/puyuan/code/LightZero/lzero/mcts/ctree/alphazero/ctree_alphazero/build') + +import mcts_alphazero +n = mcts_alphazero.Node() +print(n.is_leaf()) +print(n.update(5.0)) +print(n.value()) \ No newline at end of file diff --git a/lzero/mcts/ctree/alphazero/ctree_alphazero/test_node_alphazero_bkp.py b/lzero/mcts/ctree/alphazero/ctree_alphazero/test_node_alphazero_bkp.py new file mode 100644 index 000000000..65563eea4 --- /dev/null +++ b/lzero/mcts/ctree/alphazero/ctree_alphazero/test_node_alphazero_bkp.py @@ -0,0 +1,7 @@ +import sys +sys.path.append('/Users/puyuan/code/LightZero/lzero/mcts/ctree/alphazero/ctree_alphazero/build') + +import node_alphazero +n = node_alphazero.Node() +n.update(5.0) +print(n.get_value()) \ No newline at end of file diff --git a/lzero/mcts/ctree/alphazero/cython_alphazero/node.pyx.bkp b/lzero/mcts/ctree/alphazero/cython_alphazero/node.pyx.bkp new file mode 100644 index 000000000..7d4a8892e --- /dev/null +++ b/lzero/mcts/ctree/alphazero/cython_alphazero/node.pyx.bkp @@ -0,0 +1,68 @@ +""" +The Node and MCTS class for AlphaZero. +""" + +import copy +import math + +import numpy as np +import torch +import torch.nn as nn +from easydict import EasyDict +from typing import List, Dict, Any, Tuple, Union, Callable, Type +from ding.envs import BaseEnv + + +cdef class Node: + cdef Node _parent + cdef dict _children + cdef int _visit_count + cdef float _value_sum, prior_p + + def __cinit__(self, Node parent=None, float prior_p=1.0): + self._parent = parent + self._children = {} + self._visit_count = 0 + self._value_sum = 0 + self.prior_p = prior_p + + cpdef float value(self): + if self._visit_count == 0: + return 0 + return self._value_sum / self._visit_count + + cpdef update(self, float value): + self._visit_count += 1 + self._value_sum += value + + cpdef update_recursive(self, float leaf_value, str mcts_mode): + if mcts_mode == 'self_play_mode': + self.update(leaf_value) + if self._parent is None: + return + self._parent.update_recursive(-leaf_value, mcts_mode) + if mcts_mode == 'play_with_bot_mode': + self.update(leaf_value) + if self._parent is None: + return + self._parent.update_recursive(leaf_value, mcts_mode) + + cpdef dict is_leaf(self): + return self._children == {} + + cpdef bint is_root(self): + return self._parent is None + + @property + def parent(self) -> None: + return self._parent + + @property + def children(self) -> None: + return self._children + + @property + def visit_count(self) -> None: + return self._visit_count + + diff --git a/lzero/mcts/ctree/alphazero/pybind11_test/CMakeLists.txt b/lzero/mcts/ctree/alphazero/pybind11_test/CMakeLists.txt new file mode 100644 index 000000000..c990a95e7 --- /dev/null +++ b/lzero/mcts/ctree/alphazero/pybind11_test/CMakeLists.txt @@ -0,0 +1,24 @@ +# cmake_minimum_required(VERSION 2.8.12) +cmake_minimum_required(VERSION 3.4...3.18) + +# cmake_policy(SET CMP0048 NEW) +project(pybind11_example VERSION 1.0) + +# 找到 Python +find_package(Python3 COMPONENTS Interpreter Development REQUIRED) + +add_subdirectory(pybind11) +pybind11_add_module(pybind11_example pybind11_example.cpp) + +# 将Python头文件路径添加到你的库的包含路径中 +target_include_directories(pybind11_example PRIVATE ${Python3_INCLUDE_DIRS}) + +# 链接你的库和 pybind11::module +target_link_libraries(pybind11_example PRIVATE pybind11::module) + +# 设置你的库的Python版本 +set_target_properties(pybind11_example PROPERTIES PYTHON_STANDARD ${Python3_VERSION}) + + + +# CMakeLists.txt \ No newline at end of file diff --git a/lzero/mcts/ctree/alphazero/pybind11_test/test_pybind11_example.py b/lzero/mcts/ctree/alphazero/pybind11_test/test_pybind11_example.py new file mode 100644 index 000000000..f6d2f969d --- /dev/null +++ b/lzero/mcts/ctree/alphazero/pybind11_test/test_pybind11_example.py @@ -0,0 +1,5 @@ +import sys +sys.path.append('/Users/puyuan/code/LightZero/lzero/mcts/ctree/alphazero/pybind11_test/build') + +import pybind11_example +print(pybind11_example.add(1, 2)) # Output: 3 \ No newline at end of file diff --git a/lzero/mcts/ctree/ctree_sampled_efficientzero/ezs_tree.pyx b/lzero/mcts/ctree/ctree_sampled_efficientzero/ezs_tree.pyx index 0089e9c9c..b97afa3e4 100644 --- a/lzero/mcts/ctree/ctree_sampled_efficientzero/ezs_tree.pyx +++ b/lzero/mcts/ctree/ctree_sampled_efficientzero/ezs_tree.pyx @@ -1,10 +1,10 @@ # distutils:language=c++ # cython:language_level=3 -cimport numpy as np +# cimport numpy as np from libcpp.vector cimport vector -ctypedef np.npy_float FLOAT -ctypedef np.npy_intp INTP +# ctypedef np.npy_float FLOAT +# ctypedef np.npy_intp INTP cdef class MinMaxStatsList: cdef CMinMaxStatsList *cmin_max_stats_lst diff --git a/lzero/mcts/ptree/ptree_az_cnode.py b/lzero/mcts/ptree/ptree_az_cnode.py new file mode 100644 index 000000000..f252387de --- /dev/null +++ b/lzero/mcts/ptree/ptree_az_cnode.py @@ -0,0 +1,230 @@ +""" +The Node and MCTS class for AlphaZero. +""" + +import copy +import math + +import numpy as np +import torch +import torch.nn as nn +from easydict import EasyDict +from typing import List, Dict, Any, Tuple, Union, Callable, Type +from ding.envs import BaseEnv + +import sys +sys.path.append('/Users/puyuan/code/LightZero/lzero/mcts/ctree/alphazero/ctree_alphazero/build') + +import mcts_alphazero + +class MCTS(object): + """ + Overview: + MCTS search process. + """ + + def __init__(self, cfg: EasyDict) -> None: + self._cfg = cfg + + self._max_moves = self._cfg.get('max_moves', 512) # for chess and shogi, 722 for Go. + self._num_simulations = self._cfg.get('num_simulations', 800) + + # UCB formula + self._pb_c_base = self._cfg.get('pb_c_base', 19652) # 19652 + self._pb_c_init = self._cfg.get('pb_c_init', 1.25) # 1.25 + + # Root prior exploration noise. + self._root_dirichlet_alpha = self._cfg.get( + 'root_dirichlet_alpha', 0.3 + ) # 0.3 # for chess, 0.03 for Go and 0.15 for shogi. + self._root_noise_weight = self._cfg.get('root_noise_weight', 0.25) # 0.25 + + def get_next_action( + self, + simulate_env: Type[BaseEnv], + policy_forward_fn: Callable, + temperature: float = 1.0, + sample: bool = True + ) -> Tuple[int, List[float]]: + """ + Overview: + calculate the move probabilities based on visit counts at the root node. + Arguments: + - simulate_env (:obj:`Class BaseGameEnv`): The class of simulate env. + - policy_forward_fn (:obj:`Function`): The Callable to compute the action probs and state value. + - temperature (:obj:`Int`): Temperature is a parameter that controls the "softness" of the probability distribution. + - sample (:obj:`Bool`): The value of the node. + Returns: + - action (:obj:`Bool`): Select the action with the most visits as the final action. + - action_probs (:obj:`List`): The output probability of each action. + """ + # root = Node() + root = mcts_alphazero.Node() + + self._expand_leaf_node(root, simulate_env, policy_forward_fn) + if sample: + self._add_exploration_noise(root) + + # for debugging + # print(simulate_env.board) + # print('value= {}'.format([(k, v.value) for k,v in root.children.items()])) + # print('visit_count= {}'.format([(k, v.visit_count) for k,v in root.children.items()])) + # print('legal_action= {}',format(simulate_env.legal_actions)) + + for n in range(self._num_simulations): + simulate_env_copy = copy.deepcopy(simulate_env) + simulate_env_copy.battle_mode = simulate_env_copy.mcts_mode + self._simulate(root, simulate_env_copy, policy_forward_fn) + + # for debugging + # print('after simulation') + # print('value= {}'.format([(k, v.value) for k,v in root.children.items()])) + # print('visit_count= {}'.format([(k, v.visit_count) for k,v in root.children.items()])) + + action_visits = [] + for action in range(simulate_env.action_space.n): + if action in root.children: + action_visits.append((action, root.children[action].visit_count)) + else: + action_visits.append((action, 0)) + + actions, visits = zip(*action_visits) + action_probs = nn.functional.softmax(1.0 / temperature * np.log(torch.as_tensor(visits) + 1e-10), dim=0).numpy() + if sample: + action = np.random.choice(actions, p=action_probs) + else: + action = actions[np.argmax(action_probs)] + # print(action) + return action, action_probs + + def _simulate(self, node, simulate_env: Type[BaseEnv], policy_forward_fn: Callable) -> None: + """ + Overview: + Run a single playout from the root to the leaf, getting a value at the leaf and propagating it back through its parents. + State is modified in-place, so a deepcopy must be provided. + Arguments: + - node (:obj:`Class Node`): Current node when performing mcts search. + - simulate_env (:obj:`Class BaseGameEnv`): The class of simulate env. + - policy_forward_fn (:obj:`Function`): The Callable to compute the action probs and state value. + """ + while not node.is_leaf(): + # print(node.children.keys()) + action, node = self._select_child(node, simulate_env) + if action is None: + break + # print('legal_action={}'.format(simulate_env.legal_actions)) + # print('action={}'.format(action)) + simulate_env.step(action) + # print(node.is_leaf()) + + done, winner = simulate_env.get_done_winner() + """ + in ``self_play_mode``, the leaf_value is calculated from the perspective of player ``simulate_env.current_player``. + in ``play_with_bot_mode``, the leaf_value is calculated from the perspective of player 1. + """ + + if not done: + leaf_value = self._expand_leaf_node(node, simulate_env, policy_forward_fn) + else: + if simulate_env.mcts_mode == 'self_play_mode': + if winner == -1: + leaf_value = 0 + else: + leaf_value = 1 if simulate_env.current_player == winner else -1 + + if simulate_env.mcts_mode == 'play_with_bot_mode': + # in ``play_with_bot_mode``, the leaf_value should be transformed to the perspective of player 1. + if winner == -1: + leaf_value = 0 + elif winner == 1: + leaf_value = 1 + elif winner == 2: + leaf_value = -1 + + # Update value and visit count of nodes in this traversal. + if simulate_env.mcts_mode == 'play_with_bot_mode': + node.update_recursive(leaf_value, simulate_env.mcts_mode) + elif simulate_env.mcts_mode == 'self_play_mode': + # NOTE: e.g. + # to_play: 1 ----------> 2 ----------> 1 ----------> 2 + # state: s1 ----------> s2 ----------> s3 ----------> s4 + # action node + # leaf_value + # leaf_value is calculated from the perspective of player 1, leaf_value = value_func(s3), + # but node.value should be the value of E[q(s2, action)], i.e. calculated from the perspective of player 2. + # thus we add the negative when call update_recursive(). + node.update_recursive(-leaf_value, simulate_env.mcts_mode) + + def _select_child(self, node, simulate_env: Type[BaseEnv]):# -> Tuple[Union[int, float], Node]: + """ + Overview: + Select the child with the highest UCB score. + Arguments: + - node (:obj:`Class Node`): Current node. + Returns: + - action (:obj:`Int`): choose the action with the highest ucb score. + - child (:obj:`Node`): the child node reached by executing the action with the highest ucb score. + """ + action = None + child = None + best_score = -9999999 + # print(simulate_env._raw_env._go.board, simulate_env.legal_actions) + for action_tmp, child_tmp in node.children.items(): + if action_tmp in simulate_env.legal_actions: + score = self._ucb_score(node, child_tmp) + if score > best_score: + best_score = score + action = action_tmp + child = child_tmp + if child is None: + child = node # child==None, node is leaf node in play_with_bot_mode. + + return action, child + + def _expand_leaf_node(self, node, simulate_env: Type[BaseEnv], policy_forward_fn: Callable) -> float: + """ + Overview: + expand the node with the policy_forward_fn. + Arguments: + - node (:obj:`Class Node`): current node when performing mcts search. + - simulate_env (:obj:`Class BaseGameEnv`): the class of simulate env. + - policy_forward_fn (:obj:`Function`): the Callable to compute the action probs and state value. + Returns: + - leaf_value (:obj:`Bool`): the leaf node's value. + """ + action_probs_dict, leaf_value = policy_forward_fn(simulate_env) + # simulate_env._raw_env._go.board + for action, prior_p in action_probs_dict.items(): + if action in simulate_env.legal_actions: + node.children[action] = mcts_alphazero.Node(parent=node, prior_p=prior_p) + return leaf_value + + def _ucb_score(self, parent, child) -> float: + """ + Overview: + Compute UCB score. The score for a node is based on its value, plus an exploration bonus based on the prior. + Arguments: + - parent (:obj:`Class Node`): Current node. + - child (:obj:`Class Node`): Current node's child. + Returns: + - score (:obj:`Bool`): The UCB score. + """ + pb_c = math.log((parent.visit_count + self._pb_c_base + 1) / self._pb_c_base) + self._pb_c_init + pb_c *= math.sqrt(parent.visit_count) / (child.visit_count + 1) + + prior_score = pb_c * child.prior_p + value_score = child.value + return prior_score + value_score + + def _add_exploration_noise(self, node) -> None: + """ + Overview: + Add exploration noise. + Arguments: + - node (:obj:`Class Node`): Current node. + """ + actions = node.children.keys() + noise = np.random.gamma(self._root_dirichlet_alpha, 1, len(actions)) + frac = self._root_noise_weight + for a, n in zip(actions, noise): + node.children[a].prior_p = node.children[a].prior_p * (1 - frac) + n * frac diff --git a/lzero/policy/alphazero.py b/lzero/policy/alphazero.py index bde33f5d1..7ecdcdfae 100644 --- a/lzero/policy/alphazero.py +++ b/lzero/policy/alphazero.py @@ -10,7 +10,11 @@ from ding.utils import POLICY_REGISTRY from ding.utils.data import default_collate -from lzero.mcts.ptree.ptree_az import MCTS +from lzero.mcts.ptree.ptree_az_cnode import MCTS +import sys +sys.path.append('/Users/puyuan/code/LightZero/lzero/mcts/ctree/alphazero/ctree_alphazero/build') +import mcts_alphazero + from lzero.policy import configure_optimizers @@ -37,6 +41,8 @@ class AlphaZeroPolicy(Policy): # (int) The number of channels of hidden states in AlphaZero model. num_channels=32, ), + # (bool) Whether to use C++ MCTS in policy. If False, use Python implementation. + mcts_ctree=True, # (bool) Whether to use cuda for network. cuda=False, # (int) How many updates(iterations) to train after collector's one collection. @@ -208,8 +214,14 @@ def _init_collect(self) -> None: Overview: Collect mode init method. Called by ``self.__init__``. Initialize the collect model and MCTS utils. """ - self._collect_mcts = MCTS(self._cfg.mcts) + # self._collect_mcts = MCTS(self._cfg.mcts) self._collect_model = self._model + if self._cfg.mcts_ctree: + self._collect_mcts = mcts_alphazero.MCTS(self._cfg.mcts.max_moves, self._cfg.mcts.num_simulations, self._cfg.mcts.pb_c_base, + self._cfg.mcts.pb_c_init, self._cfg.mcts.root_dirichlet_alpha, self._cfg.mcts.root_noise_weight) + else: + self._collect_mcts = MCTS(self._cfg.mcts) + self.collect_mcts_temperature = 1 @torch.no_grad() @@ -240,13 +252,20 @@ def _forward_collect(self, envs: Dict, obs: Dict, temperature: float = 1) -> Dic init_state=init_state[env_id], katago_policy_init=False, ) + # action, mcts_probs = self._collect_mcts.get_next_action( + # envs[env_id], + # policy_forward_fn=self._policy_value_fn, + # temperature=self.collect_mcts_temperature, + # sample=True, + # ) action, mcts_probs = self._collect_mcts.get_next_action( envs[env_id], - policy_forward_fn=self._policy_value_fn, - temperature=self.collect_mcts_temperature, - # sample=False, - sample=True, + self._policy_value_fn, + self.collect_mcts_temperature, + True, ) + # sample=False, + output[env_id] = { 'action': action, 'probs': mcts_probs, @@ -259,7 +278,18 @@ def _init_eval(self) -> None: Overview: Evaluate mode init method. Called by ``self.__init__``. Initialize the eval model and MCTS utils. """ - self._eval_mcts = MCTS(self._cfg.mcts) + # self._eval_mcts = MCTS(self._cfg.mcts) + + if self._cfg.mcts_ctree: + self._eval_mcts = mcts_alphazero.MCTS(self._cfg.mcts.max_moves, self._cfg.mcts.num_simulations, self._cfg.mcts.pb_c_base, + self._cfg.mcts.pb_c_init, self._cfg.mcts.root_dirichlet_alpha, self._cfg.mcts.root_noise_weight) + print("="*20) + print(self._eval_mcts) + print("="*20) + + else: + self._eval_mcts = MCTS(self._cfg.mcts) + self._eval_model = self._model def _forward_eval(self, envs: Dict, obs: Dict) -> Dict[str, torch.Tensor]: @@ -287,9 +317,16 @@ def _forward_eval(self, envs: Dict, obs: Dict) -> Dict[str, torch.Tensor]: init_state=init_state[env_id], katago_policy_init=False, ) - action, mcts_probs = self._eval_mcts.get_next_action( - envs[env_id], policy_forward_fn=self._policy_value_fn, temperature=1.0, sample=False - ) + try: + action, mcts_probs = self._eval_mcts.get_next_action(envs[env_id], self._policy_value_fn, 1.0, False) + except Exception as e: + print(f"Exception occurred: {e}") + print(f"Type of envs[env_id]: {type(envs[env_id])}") + print(f"Is self._policy_value_fn callable? {callable(self._policy_value_fn)}") + raise # re-raise the exception + print("="*20) + print(action, mcts_probs) + print("="*20) output[env_id] = { 'action': action, 'probs': mcts_probs, diff --git a/zoo/board_games/go/envs/katago_policy.py b/zoo/board_games/go/envs/katago_policy.py index 91020a3e0..e35a3b4fe 100644 --- a/zoo/board_games/go/envs/katago_policy.py +++ b/zoo/board_games/go/envs/katago_policy.py @@ -653,7 +653,7 @@ def katago_command(self, game_state, command, to_play=None): print('?%s ???\n\n' % (cmdid,), end='') sys.stdout.flush() - def get_outgiputs(self, gs, rules): + def get_outputs(self, gs, rules): with torch.no_grad(): self.model.eval() diff --git a/zoo/board_games/go/envs/test_go_mcts_bot.py b/zoo/board_games/go/envs/test_go_mcts_bot.py index 7abf407e8..758593fe1 100644 --- a/zoo/board_games/go/envs/test_go_mcts_bot.py +++ b/zoo/board_games/go/envs/test_go_mcts_bot.py @@ -1,5 +1,6 @@ from easydict import EasyDict from zoo.board_games.go.envs.go_env import GoEnv, flatten_action_to_gtp_action +from zoo.board_games.go.envs.katago_policy import KatagoPolicy from zoo.board_games.mcts_bot import MCTSBot import pytest @@ -13,7 +14,8 @@ # num_simulations=20, save_gif_replay=False, render_in_ui=False, - katago_checkpoint_path="/Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", + # katago_checkpoint_path="/Users/puyuan/code/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", + katago_checkpoint_path="/mnt/nfs/puyuan/KataGo/kata1-b18c384nbt-s6582191360-d3422816034/model.ckpt", ignore_pass_if_have_other_legal_actions=True, save_gif_path='./', komi=7.5, @@ -26,8 +28,13 @@ bot_action_type='alpha_beta_pruning', # {'v0', 'alpha_beta_pruning'} prob_random_action_in_bot=0., check_action_to_connect4_in_bot_v0=False, + katago_device='cpu', )) +cfg.katago_policy = KatagoPolicy(checkpoint_path=cfg.katago_checkpoint_path, board_size=cfg.board_size, + ignore_pass_if_have_other_legal_actions=cfg.ignore_pass_if_have_other_legal_actions, + device=cfg.katago_device) + @pytest.mark.envtest class TestGoBot: @@ -150,14 +157,14 @@ class TestGoBot: # # player_0 num_simulation=1000 # # player_1 num_simulation=1000, will draw # cfg.num_simulations = 50 - # + # env = GoEnv(cfg) # obs = env.reset() # state = obs['board'] - # + # player_1 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 # player_2 = MCTSBot(GoEnv, cfg, 'player 2', cfg.num_simulations) # player_index = 1, player = 2 - # + # player_index = 0 # player 1 fist # print(state) # print('-' * 40) @@ -170,30 +177,28 @@ class TestGoBot: # action = player_2.get_actions(state, player_index=player_index) # player_index = 0 # timestep = env.step(action) - # + # env.render('human') # # time.sleep(0.1) - # + # state = timestep.obs['board'] # print('-' * 40) # print(state) # assert env.get_done_winner()[1] == -1, f'winner is {env.get_done_winner()[1]}, two players should draw' - # - def test_go_self_play_mode_case_1(self): env = GoEnv(cfg) init_state = np.array([ - [-1, -1, 1, -1, 0, 0], - [ 0, 0, 0, 0, -1, 0], - [ 0, 0, 0, 0, 0, -1], - [ 0, 0, 0, 0, 1, 0], - [-1, 0, 0, -1, -1, 1], - [ 0, -1, 0, 1, 1, 0], + [-1, -1, 1, -1, 0, 0], + [0, 0, 0, 0, -1, 0], + [0, 0, 0, 0, 0, -1], + [0, 0, 0, 0, 1, 0], + [-1, 0, 0, -1, -1, 1], + [0, -1, 0, 1, 1, 0], ]) # TODO - cfg.num_simulations = 500 + cfg.num_simulations = 50 player_1 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 player_2 = MCTSBot(GoEnv, cfg, 'player 2', cfg.num_simulations) # player_index = 1, player = 2 @@ -208,17 +213,20 @@ def test_go_self_play_mode_case_1(self): if player_index == 0: action = player_1.get_actions(state, player_index=player_index) print(f"mcts_gtp_action: {flatten_action_to_gtp_action(action, cfg.board_size)} for case 1") - break + else: + action = player_2.get_actions(state, player_index=player_index) + print(f"mcts_gtp_action: {flatten_action_to_gtp_action(action, cfg.board_size)} for case 1") + player_index = 0 def test_go_self_play_mode_case_2(self): env = GoEnv(cfg) init_state = np.array([ - [ 0, 0, 0, 0, 0, 0], - [-1, 0, 0, 0, -1, 0], - [ 0, -1, 0, 0, -1, 0], - [-1, -1, 1, 1, -1, -1], - [ 1, 1, 0, 0, 1, 1], - [ 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0], + [-1, 0, 0, 0, -1, 0], + [0, -1, 0, 0, -1, 0], + [-1, -1, 1, 1, -1, -1], + [1, 1, 0, 0, 1, 1], + [0, 0, 0, 0, 0, 0], ]) # TODO cfg.num_simulations = 50 @@ -236,20 +244,23 @@ def test_go_self_play_mode_case_2(self): if player_index == 0: action = player_1.get_actions(state, player_index=player_index) print(f"mcts_gtp_action: {flatten_action_to_gtp_action(action, cfg.board_size)} for case 2") - break + else: + action = player_2.get_actions(state, player_index=player_index) + print(f"mcts_gtp_action: {flatten_action_to_gtp_action(action, cfg.board_size)} for case 2") + player_index = 0 def test_go_self_play_mode_case_3(self): env = GoEnv(cfg) init_state = np.array([ - [ 1, 1, 1, 1, 0, 0], - [ 1, -1, -1, 1, 1, 1], - [ 1, 0, 0, -1, -1, 1], - [ 1, -1, 0, 1, -1, 1], - [ 1, -1, 1, 1, -1, 1], - [-1, -1, -1, -1, -1, 1], + [1, 1, 1, 1, 0, 0], + [1, -1, -1, 1, 1, 1], + [1, 0, 0, -1, -1, 1], + [1, -1, 0, 1, -1, 1], + [1, -1, 1, 1, -1, 1], + [-1, -1, -1, -1, -1, 1], ]) # TODO - cfg.num_simulations = 500 + cfg.num_simulations = 50 player_1 = MCTSBot(GoEnv, cfg, 'player 1', cfg.num_simulations) # player_index = 0, player = 1 player_2 = MCTSBot(GoEnv, cfg, 'player 2', cfg.num_simulations) # player_index = 1, player = 2 @@ -264,10 +275,17 @@ def test_go_self_play_mode_case_3(self): if player_index == 0: action = player_1.get_actions(state, player_index=player_index) print(f"mcts_gtp_action: {flatten_action_to_gtp_action(action, cfg.board_size)} for case 3") - break + else: + action = player_2.get_actions(state, player_index=player_index) + print(f"mcts_gtp_action: {flatten_action_to_gtp_action(action, cfg.board_size)} for case 3") + player_index = 0 # test = TestGoBot().test_go_self_play_mode_player1_win() # test = TestGoBot().test_go_self_play_mode_draw() # test = TestGoBot().test_go_mcts_vs_human() -test = TestGoBot().test_go_self_play_mode_case_1() +# test = TestGoBot().test_go_self_play_mode_case_1() +# test = TestGoBot().test_go_self_play_mode_case_2() +# test = TestGoBot().test_go_self_play_mode_case_3() + + diff --git a/zoo/board_games/tictactoe/config/tictactoe_alphazero_sp_mode_config.py b/zoo/board_games/tictactoe/config/tictactoe_alphazero_sp_mode_config.py index aebc449f6..59ea82bed 100644 --- a/zoo/board_games/tictactoe/config/tictactoe_alphazero_sp_mode_config.py +++ b/zoo/board_games/tictactoe/config/tictactoe_alphazero_sp_mode_config.py @@ -24,6 +24,7 @@ evaluator_env_num=evaluator_env_num, n_evaluator_episode=evaluator_env_num, manager=dict(shared_memory=False, ), + use_katago_bot=False, ), policy=dict( model=dict( diff --git a/zoo/board_games/tictactoe/envs/tictactoe_env.py b/zoo/board_games/tictactoe/envs/tictactoe_env.py index 941614912..e73e516f9 100644 --- a/zoo/board_games/tictactoe/envs/tictactoe_env.py +++ b/zoo/board_games/tictactoe/envs/tictactoe_env.py @@ -77,6 +77,11 @@ def __init__(self, cfg=None): if 'alpha_beta_pruning' in self.bot_action_type: self.alpha_beta_pruning_player = AlphaBetaPruningBot(self, cfg, 'alpha_beta_pruning_player') + def legal_actions_func(self): + # Convert NumPy arrays to nested tuples to make them hashable. + return _legal_actions_func_lru(tuple(map(tuple, self.board))) + + @property def legal_actions(self): # Convert NumPy arrays to nested tuples to make them hashable. diff --git a/zoo/classic_control/cartpole/config/cartpole_muzero_config.py b/zoo/classic_control/cartpole/config/cartpole_muzero_config.py index c25dfcb52..bd0f0ef42 100644 --- a/zoo/classic_control/cartpole/config/cartpole_muzero_config.py +++ b/zoo/classic_control/cartpole/config/cartpole_muzero_config.py @@ -25,6 +25,7 @@ evaluator_env_num=evaluator_env_num, n_evaluator_episode=evaluator_env_num, manager=dict(shared_memory=False, ), + stop_valuee=int(1e6), ), policy=dict( model=dict( From 0f4803c7fdfc1566dca413aa43bf371e6ac24726 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E8=92=B2=E6=BA=90?= <2402552459@qq.com> Date: Fri, 21 Jul 2023 14:56:47 +0800 Subject: [PATCH 23/34] feature(pu): add init version of alphazero ctree --- lzero/mcts/ctree/alphazero/cmake_example | 1 - .../test_node_alphazero_bkp.py | 7 - .../alphazero/cython_alphazero/node.pyx.bkp | 68 - .../alphazero/pybind11_test/CMakeLists.txt | 24 - .../pybind11_test/test_pybind11_example.py | 5 - .../ctree_alphazero/CMakeLists.txt | 0 .../ctree_alphazero/CMakeLists_mcts.txt | 0 .../ctree_alphazero/CMakeLists_node.txt | 0 .../ctree_alphazero/build/CMakeCache.txt | 511 +++ .../CMakeFiles/3.18.4/CMakeCCompiler.cmake | 77 + .../CMakeFiles/3.18.4/CMakeCXXCompiler.cmake | 89 + .../3.18.4/CMakeDetermineCompilerABI_C.bin | Bin 0 -> 16592 bytes .../3.18.4/CMakeDetermineCompilerABI_CXX.bin | Bin 0 -> 16576 bytes .../build/CMakeFiles/3.18.4/CMakeSystem.cmake | 15 + .../3.18.4/CompilerIdC/CMakeCCompilerId.c | 674 ++++ .../3.18.4/CompilerIdC/CMakeCCompilerId.o | Bin 0 -> 1400 bytes .../CompilerIdCXX/CMakeCXXCompilerId.cpp | 663 ++++ .../3.18.4/CompilerIdCXX/CMakeCXXCompilerId.o | Bin 0 -> 1384 bytes .../CMakeDirectoryInformation.cmake | 16 + .../build/CMakeFiles/CMakeError.log | 22 + .../build/CMakeFiles/CMakeOutput.log | 290 ++ .../build/CMakeFiles/Makefile.cmake | 138 + .../build/CMakeFiles/Makefile2 | 145 + .../build/CMakeFiles/TargetDirectories.txt | 5 + .../build/CMakeFiles/cmake.check_cache | 1 + .../mcts_alphazero.dir/CXX.includecache | 718 ++++ .../mcts_alphazero.dir/DependInfo.cmake | 28 + .../CMakeFiles/mcts_alphazero.dir/build.make | 133 + .../mcts_alphazero.dir/cmake_clean.cmake | 11 + .../mcts_alphazero.dir/depend.internal | 215 ++ .../CMakeFiles/mcts_alphazero.dir/depend.make | 215 ++ .../CMakeFiles/mcts_alphazero.dir/flags.make | 10 + .../CMakeFiles/mcts_alphazero.dir/link.txt | 1 + .../mcts_alphazero.dir/mcts_alphazero.cpp.o | Bin 0 -> 2448640 bytes .../mcts_alphazero.dir/node_alphazero.cpp.o | Bin 0 -> 1973568 bytes .../mcts_alphazero.dir/progress.make | 4 + .../build/CMakeFiles/progress.marks | 1 + .../mcts/ctree/ctree_alphazero/build/Makefile | 227 ++ .../ctree_alphazero/build/cmake_install.cmake | 54 + .../build/mcts_alphazero.cpython-38-darwin.so | Bin 0 -> 485632 bytes .../CMakeDirectoryInformation.cmake | 16 + .../build/pybind11/CMakeFiles/progress.marks | 1 + .../ctree_alphazero/build/pybind11/Makefile | 153 + .../build/pybind11/cmake_install.cmake | 39 + .../ctree/ctree_alphazero/mcts_alphazero.cpp | 334 ++ .../ctree_alphazero/mcts_alphazero_nopy.cpp | 299 ++ .../ctree/ctree_alphazero/node_alphazero.cpp | 29 + .../ctree/ctree_alphazero/node_alphazero.h | 63 + .../ctree_alphazero/node_alphazero_bkp.cpp | 89 + .../ctree_alphazero/pybind11/.appveyor.yml | 35 + .../ctree_alphazero/pybind11/.clang-format | 38 + .../ctree_alphazero/pybind11/.clang-tidy | 77 + .../pybind11/.cmake-format.yaml | 73 + .../pybind11/.codespell-ignore-lines | 24 + .../ctree_alphazero/pybind11/.gitattributes | 1 + .../pybind11/.github/CODEOWNERS | 9 + .../pybind11/.github/CONTRIBUTING.md | 388 +++ .../.github/ISSUE_TEMPLATE/bug-report.yml | 61 + .../.github/ISSUE_TEMPLATE/config.yml | 8 + .../pybind11/.github/dependabot.yml | 7 + .../pybind11/.github/labeler.yml | 8 + .../pybind11/.github/labeler_merged.yml | 3 + .../pybind11/.github/matchers/pylint.json | 32 + .../pybind11/.github/pull_request_template.md | 19 + .../pybind11/.github/workflows/ci.yml | 1165 +++++++ .../pybind11/.github/workflows/configure.yml | 92 + .../pybind11/.github/workflows/format.yml | 60 + .../pybind11/.github/workflows/labeler.yml | 25 + .../pybind11/.github/workflows/pip.yml | 114 + .../pybind11/.github/workflows/upstream.yml | 116 + .../ctree/ctree_alphazero/pybind11/.gitignore | 46 + .../pybind11/.pre-commit-config.yaml | 153 + .../ctree_alphazero/pybind11/.readthedocs.yml | 3 + .../CMakeDirectoryInformation.cmake | 16 + .../pybind11/CMakeFiles/progress.marks | 1 + .../ctree_alphazero/pybind11/CMakeLists.txt | 322 ++ .../ctree/ctree_alphazero/pybind11/LICENSE | 29 + .../ctree_alphazero/pybind11/MANIFEST.in | 6 + .../ctree/ctree_alphazero/pybind11/Makefile | 153 + .../ctree/ctree_alphazero/pybind11/README.rst | 180 + .../ctree_alphazero/pybind11/SECURITY.md | 13 + .../pybind11/cmake_install.cmake | 39 + .../ctree_alphazero/pybind11/docs/Doxyfile | 21 + .../ctree_alphazero/pybind11/docs/Makefile | 192 ++ .../pybind11/docs/_static/css/custom.css | 3 + .../pybind11/docs/advanced/cast/chrono.rst | 81 + .../pybind11/docs/advanced/cast/custom.rst | 93 + .../pybind11/docs/advanced/cast/eigen.rst | 310 ++ .../docs/advanced/cast/functional.rst | 109 + .../pybind11/docs/advanced/cast/index.rst | 43 + .../pybind11/docs/advanced/cast/overview.rst | 170 + .../pybind11/docs/advanced/cast/stl.rst | 249 ++ .../pybind11/docs/advanced/cast/strings.rst | 296 ++ .../pybind11/docs/advanced/classes.rst | 1335 ++++++++ .../pybind11/docs/advanced/embedding.rst | 262 ++ .../pybind11/docs/advanced/exceptions.rst | 401 +++ .../pybind11/docs/advanced/functions.rst | 614 ++++ .../pybind11/docs/advanced/misc.rst | 400 +++ .../pybind11/docs/advanced/pycpp/index.rst | 13 + .../pybind11/docs/advanced/pycpp/numpy.rst | 455 +++ .../pybind11/docs/advanced/pycpp/object.rst | 286 ++ .../docs/advanced/pycpp/utilities.rst | 155 + .../pybind11/docs/advanced/smart_ptrs.rst | 174 + .../ctree_alphazero/pybind11/docs/basics.rst | 307 ++ .../pybind11/docs/benchmark.py | 87 + .../pybind11/docs/benchmark.rst | 95 + .../pybind11/docs/changelog.rst | 2832 ++++++++++++++++ .../ctree_alphazero/pybind11/docs/classes.rst | 555 ++++ .../pybind11/docs/cmake/index.rst | 8 + .../pybind11/docs/compiling.rst | 641 ++++ .../ctree_alphazero/pybind11/docs/conf.py | 368 +++ .../ctree_alphazero/pybind11/docs/faq.rst | 308 ++ .../ctree_alphazero/pybind11/docs/index.rst | 48 + .../pybind11/docs/installing.rst | 105 + .../pybind11/docs/limitations.rst | 72 + .../pybind11/docs/pybind11-logo.png | Bin 0 -> 61034 bytes .../docs/pybind11_vs_boost_python1.png | Bin 0 -> 44653 bytes .../docs/pybind11_vs_boost_python1.svg | 427 +++ .../docs/pybind11_vs_boost_python2.png | Bin 0 -> 41121 bytes .../docs/pybind11_vs_boost_python2.svg | 427 +++ .../pybind11/docs/reference.rst | 130 + .../ctree_alphazero/pybind11/docs/release.rst | 102 + .../pybind11/docs/requirements.txt | 6 + .../ctree_alphazero/pybind11/docs/upgrade.rst | 566 ++++ .../pybind11/include/pybind11/attr.h | 690 ++++ .../pybind11/include/pybind11/buffer_info.h | 208 ++ .../pybind11/include/pybind11/cast.h | 1704 ++++++++++ .../pybind11/include/pybind11/chrono.h | 225 ++ .../pybind11/include/pybind11/common.h | 2 + .../pybind11/include/pybind11/complex.h | 74 + .../pybind11/include/pybind11/detail/class.h | 743 +++++ .../pybind11/include/pybind11/detail/common.h | 1255 +++++++ .../pybind11/include/pybind11/detail/descr.h | 171 + .../pybind11/include/pybind11/detail/init.h | 434 +++ .../include/pybind11/detail/internals.h | 656 ++++ .../pybind11/detail/type_caster_base.h | 1177 +++++++ .../pybind11/include/pybind11/detail/typeid.h | 65 + .../pybind11/include/pybind11/eigen.h | 12 + .../pybind11/include/pybind11/eigen/common.h | 9 + .../pybind11/include/pybind11/eigen/matrix.h | 714 ++++ .../pybind11/include/pybind11/eigen/tensor.h | 516 +++ .../pybind11/include/pybind11/embed.h | 316 ++ .../pybind11/include/pybind11/eval.h | 156 + .../pybind11/include/pybind11/functional.h | 137 + .../pybind11/include/pybind11/gil.h | 239 ++ .../pybind11/include/pybind11/iostream.h | 265 ++ .../pybind11/include/pybind11/numpy.h | 1998 ++++++++++++ .../pybind11/include/pybind11/operators.h | 202 ++ .../pybind11/include/pybind11/options.h | 92 + .../pybind11/include/pybind11/pybind11.h | 2890 +++++++++++++++++ .../pybind11/include/pybind11/pytypes.h | 2557 +++++++++++++++ .../pybind11/include/pybind11/stl.h | 447 +++ .../include/pybind11/stl/filesystem.h | 116 + .../pybind11/include/pybind11/stl_bind.h | 851 +++++ .../pybind11/type_caster_pyobject_ptr.h | 61 + .../ctree/ctree_alphazero/pybind11/noxfile.py | 107 + .../pybind11/pybind11/__init__.py | 17 + .../pybind11/pybind11/__main__.py | 62 + .../pybind11/pybind11/_version.py | 12 + .../pybind11/pybind11/commands.py | 37 + .../pybind11/pybind11/py.typed | 0 .../pybind11/pybind11/setup_helpers.py | 498 +++ .../ctree_alphazero/pybind11/pyproject.toml | 98 + .../ctree/ctree_alphazero/pybind11/setup.cfg | 43 + .../ctree/ctree_alphazero/pybind11/setup.py | 150 + .../pybind11/tests/CMakeLists.txt | 584 ++++ .../pybind11/tests/conftest.py | 221 ++ .../pybind11/tests/constructor_stats.h | 322 ++ .../pybind11/tests/cross_module_gil_utils.cpp | 108 + ...s_module_interleaved_error_already_set.cpp | 51 + .../tests/eigen_tensor_avoid_stl_array.cpp | 14 + .../ctree_alphazero/pybind11/tests/env.py | 27 + .../tests/extra_python_package/pytest.ini | 0 .../tests/extra_python_package/test_files.py | 291 ++ .../tests/extra_setuptools/pytest.ini | 0 .../extra_setuptools/test_setuphelper.py | 151 + .../pybind11/tests/local_bindings.h | 92 + .../ctree_alphazero/pybind11/tests/object.h | 205 ++ .../tests/pybind11_cross_module_tests.cpp | 149 + .../pybind11/tests/pybind11_tests.cpp | 123 + .../pybind11/tests/pybind11_tests.h | 85 + .../ctree_alphazero/pybind11/tests/pytest.ini | 22 + .../pybind11/tests/requirements.txt | 9 + .../pybind11/tests/test_async.cpp | 25 + .../pybind11/tests/test_async.py | 24 + .../pybind11/tests/test_buffers.cpp | 259 ++ .../pybind11/tests/test_buffers.py | 221 ++ .../pybind11/tests/test_builtin_casters.cpp | 392 +++ .../pybind11/tests/test_builtin_casters.py | 528 +++ .../pybind11/tests/test_call_policies.cpp | 115 + .../pybind11/tests/test_call_policies.py | 247 ++ .../pybind11/tests/test_callbacks.cpp | 280 ++ .../pybind11/tests/test_callbacks.py | 218 ++ .../pybind11/tests/test_chrono.cpp | 81 + .../pybind11/tests/test_chrono.py | 205 ++ .../pybind11/tests/test_class.cpp | 657 ++++ .../pybind11/tests/test_class.py | 485 +++ .../tests/test_cmake_build/CMakeLists.txt | 81 + .../pybind11/tests/test_cmake_build/embed.cpp | 23 + .../installed_embed/CMakeLists.txt | 28 + .../installed_function/CMakeLists.txt | 39 + .../installed_target/CMakeLists.txt | 46 + .../pybind11/tests/test_cmake_build/main.cpp | 6 + .../subdirectory_embed/CMakeLists.txt | 41 + .../subdirectory_function/CMakeLists.txt | 35 + .../subdirectory_target/CMakeLists.txt | 41 + .../pybind11/tests/test_cmake_build/test.py | 8 + .../pybind11/tests/test_const_name.cpp | 55 + .../pybind11/tests/test_const_name.py | 29 + .../tests/test_constants_and_functions.cpp | 154 + .../tests/test_constants_and_functions.py | 56 + .../pybind11/tests/test_copy_move.cpp | 533 +++ .../pybind11/tests/test_copy_move.py | 132 + .../tests/test_custom_type_casters.cpp | 209 ++ .../tests/test_custom_type_casters.py | 122 + .../pybind11/tests/test_custom_type_setup.cpp | 41 + .../pybind11/tests/test_custom_type_setup.py | 48 + .../pybind11/tests/test_docstring_options.cpp | 141 + .../pybind11/tests/test_docstring_options.py | 64 + .../pybind11/tests/test_eigen_matrix.cpp | 428 +++ .../pybind11/tests/test_eigen_matrix.py | 807 +++++ .../pybind11/tests/test_eigen_tensor.cpp | 18 + .../pybind11/tests/test_eigen_tensor.inl | 333 ++ .../pybind11/tests/test_eigen_tensor.py | 288 ++ .../pybind11/tests/test_embed/CMakeLists.txt | 47 + .../pybind11/tests/test_embed/catch.cpp | 43 + .../tests/test_embed/external_module.cpp | 20 + .../tests/test_embed/test_interpreter.cpp | 488 +++ .../tests/test_embed/test_interpreter.py | 14 + .../tests/test_embed/test_trampoline.py | 16 + .../pybind11/tests/test_enum.cpp | 133 + .../pybind11/tests/test_enum.py | 266 ++ .../pybind11/tests/test_eval.cpp | 118 + .../pybind11/tests/test_eval.py | 50 + .../pybind11/tests/test_eval_call.py | 4 + .../pybind11/tests/test_exceptions.cpp | 347 ++ .../pybind11/tests/test_exceptions.h | 13 + .../pybind11/tests/test_exceptions.py | 413 +++ .../tests/test_factory_constructors.cpp | 430 +++ .../tests/test_factory_constructors.py | 516 +++ .../pybind11/tests/test_gil_scoped.cpp | 144 + .../pybind11/tests/test_gil_scoped.py | 242 ++ .../pybind11/tests/test_iostream.cpp | 126 + .../pybind11/tests/test_iostream.py | 291 ++ .../tests/test_kwargs_and_defaults.cpp | 281 ++ .../tests/test_kwargs_and_defaults.py | 389 +++ .../pybind11/tests/test_local_bindings.cpp | 106 + .../pybind11/tests/test_local_bindings.py | 257 ++ .../tests/test_methods_and_attributes.cpp | 493 +++ .../tests/test_methods_and_attributes.py | 533 +++ .../pybind11/tests/test_modules.cpp | 125 + .../pybind11/tests/test_modules.py | 116 + .../tests/test_multiple_inheritance.cpp | 341 ++ .../tests/test_multiple_inheritance.py | 493 +++ .../pybind11/tests/test_numpy_array.cpp | 552 ++++ .../pybind11/tests/test_numpy_array.py | 668 ++++ .../pybind11/tests/test_numpy_dtypes.cpp | 614 ++++ .../pybind11/tests/test_numpy_dtypes.py | 440 +++ .../pybind11/tests/test_numpy_vectorize.cpp | 107 + .../pybind11/tests/test_numpy_vectorize.py | 266 ++ .../pybind11/tests/test_opaque_types.cpp | 77 + .../pybind11/tests/test_opaque_types.py | 58 + .../tests/test_operator_overloading.cpp | 281 ++ .../tests/test_operator_overloading.py | 151 + .../pybind11/tests/test_pickling.cpp | 194 ++ .../pybind11/tests/test_pickling.py | 93 + .../pybind11/tests/test_pytypes.cpp | 823 +++++ .../pybind11/tests/test_pytypes.py | 898 +++++ .../tests/test_sequences_and_iterators.cpp | 581 ++++ .../tests/test_sequences_and_iterators.py | 252 ++ .../pybind11/tests/test_smart_ptr.cpp | 470 +++ .../pybind11/tests/test_smart_ptr.py | 315 ++ .../pybind11/tests/test_stl.cpp | 551 ++++ .../pybind11/tests/test_stl.py | 381 +++ .../pybind11/tests/test_stl_binders.cpp | 196 ++ .../pybind11/tests/test_stl_binders.py | 355 ++ .../tests/test_tagbased_polymorphic.cpp | 147 + .../tests/test_tagbased_polymorphic.py | 28 + .../pybind11/tests/test_thread.cpp | 66 + .../pybind11/tests/test_thread.py | 42 + .../tests/test_type_caster_pyobject_ptr.cpp | 130 + .../tests/test_type_caster_pyobject_ptr.py | 104 + .../pybind11/tests/test_union.cpp | 22 + .../pybind11/tests/test_union.py | 8 + .../tests/test_unnamed_namespace_a.cpp | 38 + .../tests/test_unnamed_namespace_a.py | 34 + .../tests/test_unnamed_namespace_b.cpp | 13 + .../tests/test_unnamed_namespace_b.py | 5 + .../tests/test_vector_unique_ptr_member.cpp | 54 + .../tests/test_vector_unique_ptr_member.py | 14 + .../pybind11/tests/test_virtual_functions.cpp | 592 ++++ .../pybind11/tests/test_virtual_functions.py | 458 +++ .../pybind11/tests/valgrind-numpy-scipy.supp | 140 + .../pybind11/tests/valgrind-python.supp | 117 + .../pybind11/tools/FindCatch.cmake | 76 + .../pybind11/tools/FindEigen3.cmake | 86 + .../pybind11/tools/FindPythonLibsNew.cmake | 287 ++ .../pybind11/tools/JoinPaths.cmake | 23 + .../pybind11/tools/check-style.sh | 44 + .../pybind11/tools/cmake_uninstall.cmake.in | 23 + .../codespell_ignore_lines_from_errors.py | 39 + .../ctree_alphazero/pybind11/tools/libsize.py | 36 + .../pybind11/tools/make_changelog.py | 62 + .../pybind11/tools/pybind11.pc.in | 7 + .../pybind11/tools/pybind11Common.cmake | 405 +++ .../pybind11/tools/pybind11Config.cmake.in | 233 ++ .../pybind11/tools/pybind11NewTools.cmake | 256 ++ .../pybind11/tools/pybind11Tools.cmake | 233 ++ .../pybind11/tools/pyproject.toml | 3 + .../pybind11/tools/setup_global.py.in | 63 + .../pybind11/tools/setup_main.py.in | 44 + .../ctree_alphazero/test_mcts_alphazero.py | 8 +- .../ctree_alphazero/test_node_alphazero.py | 2 +- .../test_node_alphazero_bkp.py | 7 + lzero/mcts/ptree/ptree_az_cnode.py | 2 +- lzero/policy/alphazero.py | 20 +- .../tictactoe_alphazero_bot_mode_config.py | 1 + 317 files changed, 70487 insertions(+), 119 deletions(-) delete mode 160000 lzero/mcts/ctree/alphazero/cmake_example delete mode 100644 lzero/mcts/ctree/alphazero/ctree_alphazero/test_node_alphazero_bkp.py delete mode 100644 lzero/mcts/ctree/alphazero/cython_alphazero/node.pyx.bkp delete mode 100644 lzero/mcts/ctree/alphazero/pybind11_test/CMakeLists.txt delete mode 100644 lzero/mcts/ctree/alphazero/pybind11_test/test_pybind11_example.py rename lzero/mcts/ctree/{alphazero => }/ctree_alphazero/CMakeLists.txt (100%) rename lzero/mcts/ctree/{alphazero => }/ctree_alphazero/CMakeLists_mcts.txt (100%) rename lzero/mcts/ctree/{alphazero => }/ctree_alphazero/CMakeLists_node.txt (100%) create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeCache.txt create mode 100755 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CMakeCCompiler.cmake create mode 100755 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CMakeCXXCompiler.cmake create mode 100755 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CMakeDetermineCompilerABI_C.bin create mode 100755 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CMakeDetermineCompilerABI_CXX.bin create mode 100755 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CMakeSystem.cmake create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CompilerIdC/CMakeCCompilerId.c create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CompilerIdC/CMakeCCompilerId.o create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CompilerIdCXX/CMakeCXXCompilerId.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CompilerIdCXX/CMakeCXXCompilerId.o create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/CMakeDirectoryInformation.cmake create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/CMakeError.log create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/CMakeOutput.log create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/Makefile.cmake create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/Makefile2 create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/TargetDirectories.txt create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/cmake.check_cache create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/CXX.includecache create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/DependInfo.cmake create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/build.make create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/cmake_clean.cmake create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/depend.internal create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/depend.make create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/flags.make create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/link.txt create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/progress.make create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/progress.marks create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/Makefile create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/cmake_install.cmake create mode 100755 lzero/mcts/ctree/ctree_alphazero/build/mcts_alphazero.cpython-38-darwin.so create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/pybind11/CMakeFiles/CMakeDirectoryInformation.cmake create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/pybind11/CMakeFiles/progress.marks create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/pybind11/Makefile create mode 100644 lzero/mcts/ctree/ctree_alphazero/build/pybind11/cmake_install.cmake create mode 100644 lzero/mcts/ctree/ctree_alphazero/mcts_alphazero.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/mcts_alphazero_nopy.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/node_alphazero.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/node_alphazero.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/node_alphazero_bkp.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.appveyor.yml create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.clang-format create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.clang-tidy create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.cmake-format.yaml create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.codespell-ignore-lines create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.gitattributes create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.github/CODEOWNERS create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.github/CONTRIBUTING.md create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.github/ISSUE_TEMPLATE/bug-report.yml create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.github/ISSUE_TEMPLATE/config.yml create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.github/dependabot.yml create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.github/labeler.yml create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.github/labeler_merged.yml create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.github/matchers/pylint.json create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.github/pull_request_template.md create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/ci.yml create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/configure.yml create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/format.yml create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/labeler.yml create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/pip.yml create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/upstream.yml create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.gitignore create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.pre-commit-config.yaml create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/.readthedocs.yml create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/CMakeFiles/CMakeDirectoryInformation.cmake create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/CMakeFiles/progress.marks create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/CMakeLists.txt create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/LICENSE create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/MANIFEST.in create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/Makefile create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/README.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/SECURITY.md create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/cmake_install.cmake create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/Doxyfile create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/Makefile create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/_static/css/custom.css create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/chrono.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/custom.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/eigen.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/functional.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/index.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/overview.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/stl.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/strings.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/classes.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/embedding.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/exceptions.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/functions.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/misc.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/pycpp/index.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/pycpp/numpy.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/pycpp/object.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/pycpp/utilities.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/smart_ptrs.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/basics.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/benchmark.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/benchmark.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/changelog.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/classes.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/cmake/index.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/compiling.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/conf.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/faq.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/index.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/installing.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/limitations.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/pybind11-logo.png create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/pybind11_vs_boost_python1.png create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/pybind11_vs_boost_python1.svg create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/pybind11_vs_boost_python2.png create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/pybind11_vs_boost_python2.svg create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/reference.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/release.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/requirements.txt create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/docs/upgrade.rst create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/attr.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/buffer_info.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/cast.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/chrono.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/common.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/complex.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/detail/class.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/detail/common.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/detail/descr.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/detail/init.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/detail/internals.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/detail/type_caster_base.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/detail/typeid.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/eigen.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/eigen/common.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/eigen/matrix.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/eigen/tensor.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/embed.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/eval.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/functional.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/gil.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/iostream.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/numpy.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/operators.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/options.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/pybind11.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/pytypes.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/stl.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/stl/filesystem.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/stl_bind.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/type_caster_pyobject_ptr.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/noxfile.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/pybind11/__init__.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/pybind11/__main__.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/pybind11/_version.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/pybind11/commands.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/pybind11/py.typed create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/pybind11/setup_helpers.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/pyproject.toml create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/setup.cfg create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/setup.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/CMakeLists.txt create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/conftest.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/constructor_stats.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/cross_module_gil_utils.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/cross_module_interleaved_error_already_set.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/eigen_tensor_avoid_stl_array.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/env.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/extra_python_package/pytest.ini create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/extra_python_package/test_files.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/extra_setuptools/pytest.ini create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/extra_setuptools/test_setuphelper.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/local_bindings.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/object.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/pybind11_cross_module_tests.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/pybind11_tests.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/pybind11_tests.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/pytest.ini create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/requirements.txt create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_async.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_async.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_buffers.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_buffers.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_builtin_casters.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_builtin_casters.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_call_policies.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_call_policies.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_callbacks.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_callbacks.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_chrono.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_chrono.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_class.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_class.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_cmake_build/CMakeLists.txt create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_cmake_build/embed.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_cmake_build/installed_embed/CMakeLists.txt create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_cmake_build/installed_function/CMakeLists.txt create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_cmake_build/installed_target/CMakeLists.txt create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_cmake_build/main.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_cmake_build/subdirectory_embed/CMakeLists.txt create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_cmake_build/subdirectory_function/CMakeLists.txt create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_cmake_build/subdirectory_target/CMakeLists.txt create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_cmake_build/test.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_const_name.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_const_name.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_constants_and_functions.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_constants_and_functions.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_copy_move.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_copy_move.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_custom_type_casters.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_custom_type_casters.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_custom_type_setup.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_custom_type_setup.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_docstring_options.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_docstring_options.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_eigen_matrix.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_eigen_matrix.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_eigen_tensor.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_eigen_tensor.inl create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_eigen_tensor.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_embed/CMakeLists.txt create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_embed/catch.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_embed/external_module.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_embed/test_interpreter.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_embed/test_interpreter.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_embed/test_trampoline.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_enum.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_enum.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_eval.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_eval.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_eval_call.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_exceptions.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_exceptions.h create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_exceptions.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_factory_constructors.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_factory_constructors.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_gil_scoped.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_gil_scoped.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_iostream.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_iostream.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_kwargs_and_defaults.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_kwargs_and_defaults.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_local_bindings.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_local_bindings.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_methods_and_attributes.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_methods_and_attributes.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_modules.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_modules.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_multiple_inheritance.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_multiple_inheritance.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_numpy_array.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_numpy_array.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_numpy_dtypes.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_numpy_dtypes.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_numpy_vectorize.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_numpy_vectorize.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_opaque_types.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_opaque_types.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_operator_overloading.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_operator_overloading.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_pickling.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_pickling.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_pytypes.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_pytypes.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_sequences_and_iterators.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_sequences_and_iterators.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_smart_ptr.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_smart_ptr.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_stl.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_stl.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_stl_binders.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_stl_binders.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_tagbased_polymorphic.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_tagbased_polymorphic.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_thread.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_thread.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_type_caster_pyobject_ptr.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_type_caster_pyobject_ptr.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_union.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_union.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_unnamed_namespace_a.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_unnamed_namespace_a.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_unnamed_namespace_b.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_unnamed_namespace_b.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_vector_unique_ptr_member.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_vector_unique_ptr_member.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_virtual_functions.cpp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/test_virtual_functions.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/valgrind-numpy-scipy.supp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tests/valgrind-python.supp create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tools/FindCatch.cmake create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tools/FindEigen3.cmake create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tools/FindPythonLibsNew.cmake create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tools/JoinPaths.cmake create mode 100755 lzero/mcts/ctree/ctree_alphazero/pybind11/tools/check-style.sh create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tools/cmake_uninstall.cmake.in create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tools/codespell_ignore_lines_from_errors.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tools/libsize.py create mode 100755 lzero/mcts/ctree/ctree_alphazero/pybind11/tools/make_changelog.py create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tools/pybind11.pc.in create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tools/pybind11Common.cmake create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tools/pybind11Config.cmake.in create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tools/pybind11NewTools.cmake create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tools/pybind11Tools.cmake create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tools/pyproject.toml create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tools/setup_global.py.in create mode 100644 lzero/mcts/ctree/ctree_alphazero/pybind11/tools/setup_main.py.in rename lzero/mcts/ctree/{alphazero => }/ctree_alphazero/test_mcts_alphazero.py (66%) rename lzero/mcts/ctree/{alphazero => }/ctree_alphazero/test_node_alphazero.py (54%) create mode 100644 lzero/mcts/ctree/ctree_alphazero/test_node_alphazero_bkp.py diff --git a/lzero/mcts/ctree/alphazero/cmake_example b/lzero/mcts/ctree/alphazero/cmake_example deleted file mode 160000 index fc9fd1cf1..000000000 --- a/lzero/mcts/ctree/alphazero/cmake_example +++ /dev/null @@ -1 +0,0 @@ -Subproject commit fc9fd1cf1d8d13ca8675adf8371957ee49790e72 diff --git a/lzero/mcts/ctree/alphazero/ctree_alphazero/test_node_alphazero_bkp.py b/lzero/mcts/ctree/alphazero/ctree_alphazero/test_node_alphazero_bkp.py deleted file mode 100644 index 65563eea4..000000000 --- a/lzero/mcts/ctree/alphazero/ctree_alphazero/test_node_alphazero_bkp.py +++ /dev/null @@ -1,7 +0,0 @@ -import sys -sys.path.append('/Users/puyuan/code/LightZero/lzero/mcts/ctree/alphazero/ctree_alphazero/build') - -import node_alphazero -n = node_alphazero.Node() -n.update(5.0) -print(n.get_value()) \ No newline at end of file diff --git a/lzero/mcts/ctree/alphazero/cython_alphazero/node.pyx.bkp b/lzero/mcts/ctree/alphazero/cython_alphazero/node.pyx.bkp deleted file mode 100644 index 7d4a8892e..000000000 --- a/lzero/mcts/ctree/alphazero/cython_alphazero/node.pyx.bkp +++ /dev/null @@ -1,68 +0,0 @@ -""" -The Node and MCTS class for AlphaZero. -""" - -import copy -import math - -import numpy as np -import torch -import torch.nn as nn -from easydict import EasyDict -from typing import List, Dict, Any, Tuple, Union, Callable, Type -from ding.envs import BaseEnv - - -cdef class Node: - cdef Node _parent - cdef dict _children - cdef int _visit_count - cdef float _value_sum, prior_p - - def __cinit__(self, Node parent=None, float prior_p=1.0): - self._parent = parent - self._children = {} - self._visit_count = 0 - self._value_sum = 0 - self.prior_p = prior_p - - cpdef float value(self): - if self._visit_count == 0: - return 0 - return self._value_sum / self._visit_count - - cpdef update(self, float value): - self._visit_count += 1 - self._value_sum += value - - cpdef update_recursive(self, float leaf_value, str mcts_mode): - if mcts_mode == 'self_play_mode': - self.update(leaf_value) - if self._parent is None: - return - self._parent.update_recursive(-leaf_value, mcts_mode) - if mcts_mode == 'play_with_bot_mode': - self.update(leaf_value) - if self._parent is None: - return - self._parent.update_recursive(leaf_value, mcts_mode) - - cpdef dict is_leaf(self): - return self._children == {} - - cpdef bint is_root(self): - return self._parent is None - - @property - def parent(self) -> None: - return self._parent - - @property - def children(self) -> None: - return self._children - - @property - def visit_count(self) -> None: - return self._visit_count - - diff --git a/lzero/mcts/ctree/alphazero/pybind11_test/CMakeLists.txt b/lzero/mcts/ctree/alphazero/pybind11_test/CMakeLists.txt deleted file mode 100644 index c990a95e7..000000000 --- a/lzero/mcts/ctree/alphazero/pybind11_test/CMakeLists.txt +++ /dev/null @@ -1,24 +0,0 @@ -# cmake_minimum_required(VERSION 2.8.12) -cmake_minimum_required(VERSION 3.4...3.18) - -# cmake_policy(SET CMP0048 NEW) -project(pybind11_example VERSION 1.0) - -# 找到 Python -find_package(Python3 COMPONENTS Interpreter Development REQUIRED) - -add_subdirectory(pybind11) -pybind11_add_module(pybind11_example pybind11_example.cpp) - -# 将Python头文件路径添加到你的库的包含路径中 -target_include_directories(pybind11_example PRIVATE ${Python3_INCLUDE_DIRS}) - -# 链接你的库和 pybind11::module -target_link_libraries(pybind11_example PRIVATE pybind11::module) - -# 设置你的库的Python版本 -set_target_properties(pybind11_example PROPERTIES PYTHON_STANDARD ${Python3_VERSION}) - - - -# CMakeLists.txt \ No newline at end of file diff --git a/lzero/mcts/ctree/alphazero/pybind11_test/test_pybind11_example.py b/lzero/mcts/ctree/alphazero/pybind11_test/test_pybind11_example.py deleted file mode 100644 index f6d2f969d..000000000 --- a/lzero/mcts/ctree/alphazero/pybind11_test/test_pybind11_example.py +++ /dev/null @@ -1,5 +0,0 @@ -import sys -sys.path.append('/Users/puyuan/code/LightZero/lzero/mcts/ctree/alphazero/pybind11_test/build') - -import pybind11_example -print(pybind11_example.add(1, 2)) # Output: 3 \ No newline at end of file diff --git a/lzero/mcts/ctree/alphazero/ctree_alphazero/CMakeLists.txt b/lzero/mcts/ctree/ctree_alphazero/CMakeLists.txt similarity index 100% rename from lzero/mcts/ctree/alphazero/ctree_alphazero/CMakeLists.txt rename to lzero/mcts/ctree/ctree_alphazero/CMakeLists.txt diff --git a/lzero/mcts/ctree/alphazero/ctree_alphazero/CMakeLists_mcts.txt b/lzero/mcts/ctree/ctree_alphazero/CMakeLists_mcts.txt similarity index 100% rename from lzero/mcts/ctree/alphazero/ctree_alphazero/CMakeLists_mcts.txt rename to lzero/mcts/ctree/ctree_alphazero/CMakeLists_mcts.txt diff --git a/lzero/mcts/ctree/alphazero/ctree_alphazero/CMakeLists_node.txt b/lzero/mcts/ctree/ctree_alphazero/CMakeLists_node.txt similarity index 100% rename from lzero/mcts/ctree/alphazero/ctree_alphazero/CMakeLists_node.txt rename to lzero/mcts/ctree/ctree_alphazero/CMakeLists_node.txt diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeCache.txt b/lzero/mcts/ctree/ctree_alphazero/build/CMakeCache.txt new file mode 100644 index 000000000..a7fed9d43 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/build/CMakeCache.txt @@ -0,0 +1,511 @@ +# This is the CMakeCache file. +# For build in directory: /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build +# It was generated by CMake: /Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/bin/cmake +# You can edit this file to change values found and used by cmake. +# If you do not want to change any of the values, simply exit the editor. +# If you do want to change a value, simply edit, save, and exit the editor. +# The syntax for the file is as follows: +# KEY:TYPE=VALUE +# KEY is the name of a variable in the cache. +# TYPE is a hint to GUIs for the type of VALUE, DO NOT EDIT TYPE!. +# VALUE is the current value for the KEY. + +######################## +# EXTERNAL cache entries +######################## + +//Path to a program. +CMAKE_ADDR2LINE:FILEPATH=CMAKE_ADDR2LINE-NOTFOUND + +//Path to a program. +CMAKE_AR:FILEPATH=/Library/Developer/CommandLineTools/usr/bin/ar + +//Choose the type of build, options are: None Debug Release RelWithDebInfo +// MinSizeRel ... +CMAKE_BUILD_TYPE:STRING= + +//Enable/Disable color output during build. +CMAKE_COLOR_MAKEFILE:BOOL=ON + +//CXX compiler +CMAKE_CXX_COMPILER:FILEPATH=/Library/Developer/CommandLineTools/usr/bin/c++ + +//Flags used by the CXX compiler during all build types. +CMAKE_CXX_FLAGS:STRING= + +//Flags used by the CXX compiler during DEBUG builds. +CMAKE_CXX_FLAGS_DEBUG:STRING=-g + +//Flags used by the CXX compiler during MINSIZEREL builds. +CMAKE_CXX_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG + +//Flags used by the CXX compiler during RELEASE builds. +CMAKE_CXX_FLAGS_RELEASE:STRING=-O3 -DNDEBUG + +//Flags used by the CXX compiler during RELWITHDEBINFO builds. +CMAKE_CXX_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG + +//C compiler +CMAKE_C_COMPILER:FILEPATH=/Library/Developer/CommandLineTools/usr/bin/cc + +//Flags used by the C compiler during all build types. +CMAKE_C_FLAGS:STRING= + +//Flags used by the C compiler during DEBUG builds. +CMAKE_C_FLAGS_DEBUG:STRING=-g + +//Flags used by the C compiler during MINSIZEREL builds. +CMAKE_C_FLAGS_MINSIZEREL:STRING=-Os -DNDEBUG + +//Flags used by the C compiler during RELEASE builds. +CMAKE_C_FLAGS_RELEASE:STRING=-O3 -DNDEBUG + +//Flags used by the C compiler during RELWITHDEBINFO builds. +CMAKE_C_FLAGS_RELWITHDEBINFO:STRING=-O2 -g -DNDEBUG + +//Path to a program. +CMAKE_DLLTOOL:FILEPATH=CMAKE_DLLTOOL-NOTFOUND + +//Executable file format +CMAKE_EXECUTABLE_FORMAT:STRING=MACHO + +//Flags used by the linker during all build types. +CMAKE_EXE_LINKER_FLAGS:STRING= + +//Flags used by the linker during DEBUG builds. +CMAKE_EXE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during MINSIZEREL builds. +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during RELEASE builds. +CMAKE_EXE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during RELWITHDEBINFO builds. +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Enable/Disable output of compile commands during generation. +CMAKE_EXPORT_COMPILE_COMMANDS:BOOL= + +//User executables (bin) +CMAKE_INSTALL_BINDIR:PATH=bin + +//Read-only architecture-independent data (DATAROOTDIR) +CMAKE_INSTALL_DATADIR:PATH= + +//Read-only architecture-independent data root (share) +CMAKE_INSTALL_DATAROOTDIR:PATH=share + +//Documentation root (DATAROOTDIR/doc/PROJECT_NAME) +CMAKE_INSTALL_DOCDIR:PATH= + +//C header files (include) +CMAKE_INSTALL_INCLUDEDIR:PATH=include + +//Info documentation (DATAROOTDIR/info) +CMAKE_INSTALL_INFODIR:PATH= + +//Object code libraries (lib) +CMAKE_INSTALL_LIBDIR:PATH=lib + +//Program executables (libexec) +CMAKE_INSTALL_LIBEXECDIR:PATH=libexec + +//Locale-dependent data (DATAROOTDIR/locale) +CMAKE_INSTALL_LOCALEDIR:PATH= + +//Modifiable single-machine data (var) +CMAKE_INSTALL_LOCALSTATEDIR:PATH=var + +//Man documentation (DATAROOTDIR/man) +CMAKE_INSTALL_MANDIR:PATH= + +//Path to a program. +CMAKE_INSTALL_NAME_TOOL:FILEPATH=/usr/bin/install_name_tool + +//C header files for non-gcc (/usr/include) +CMAKE_INSTALL_OLDINCLUDEDIR:PATH=/usr/include + +//Install path prefix, prepended onto install directories. +CMAKE_INSTALL_PREFIX:PATH=/usr/local + +//Run-time variable data (LOCALSTATEDIR/run) +CMAKE_INSTALL_RUNSTATEDIR:PATH= + +//System admin executables (sbin) +CMAKE_INSTALL_SBINDIR:PATH=sbin + +//Modifiable architecture-independent data (com) +CMAKE_INSTALL_SHAREDSTATEDIR:PATH=com + +//Read-only single-machine data (etc) +CMAKE_INSTALL_SYSCONFDIR:PATH=etc + +//Path to a program. +CMAKE_LINKER:FILEPATH=/Library/Developer/CommandLineTools/usr/bin/ld + +//Path to a program. +CMAKE_MAKE_PROGRAM:FILEPATH=/usr/bin/make + +//Flags used by the linker during the creation of modules during +// all build types. +CMAKE_MODULE_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of modules during +// DEBUG builds. +CMAKE_MODULE_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of modules during +// MINSIZEREL builds. +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of modules during +// RELEASE builds. +CMAKE_MODULE_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of modules during +// RELWITHDEBINFO builds. +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_NM:FILEPATH=/Library/Developer/CommandLineTools/usr/bin/nm + +//Path to a program. +CMAKE_OBJCOPY:FILEPATH=CMAKE_OBJCOPY-NOTFOUND + +//Path to a program. +CMAKE_OBJDUMP:FILEPATH=/Library/Developer/CommandLineTools/usr/bin/objdump + +//Build architectures for OSX +CMAKE_OSX_ARCHITECTURES:STRING= + +//Minimum OS X version to target for deployment (at runtime); newer +// APIs weak linked. Set to empty string for default value. +CMAKE_OSX_DEPLOYMENT_TARGET:STRING= + +//The product will be built against the headers and libraries located +// inside the indicated SDK. +CMAKE_OSX_SYSROOT:PATH=/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk + +//Value Computed by CMake +CMAKE_PROJECT_DESCRIPTION:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_HOMEPAGE_URL:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_NAME:STATIC=mcts_alphazero + +//Value Computed by CMake +CMAKE_PROJECT_VERSION:STATIC=1.0 + +//Value Computed by CMake +CMAKE_PROJECT_VERSION_MAJOR:STATIC=1 + +//Value Computed by CMake +CMAKE_PROJECT_VERSION_MINOR:STATIC=0 + +//Value Computed by CMake +CMAKE_PROJECT_VERSION_PATCH:STATIC= + +//Value Computed by CMake +CMAKE_PROJECT_VERSION_TWEAK:STATIC= + +//Path to a program. +CMAKE_RANLIB:FILEPATH=/Library/Developer/CommandLineTools/usr/bin/ranlib + +//Path to a program. +CMAKE_READELF:FILEPATH=CMAKE_READELF-NOTFOUND + +//Flags used by the linker during the creation of shared libraries +// during all build types. +CMAKE_SHARED_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of shared libraries +// during DEBUG builds. +CMAKE_SHARED_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of shared libraries +// during MINSIZEREL builds. +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of shared libraries +// during RELEASE builds. +CMAKE_SHARED_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of shared libraries +// during RELWITHDEBINFO builds. +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//If set, runtime paths are not added when installing shared libraries, +// but are added when building. +CMAKE_SKIP_INSTALL_RPATH:BOOL=NO + +//If set, runtime paths are not added when using shared libraries. +CMAKE_SKIP_RPATH:BOOL=NO + +//Flags used by the linker during the creation of static libraries +// during all build types. +CMAKE_STATIC_LINKER_FLAGS:STRING= + +//Flags used by the linker during the creation of static libraries +// during DEBUG builds. +CMAKE_STATIC_LINKER_FLAGS_DEBUG:STRING= + +//Flags used by the linker during the creation of static libraries +// during MINSIZEREL builds. +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL:STRING= + +//Flags used by the linker during the creation of static libraries +// during RELEASE builds. +CMAKE_STATIC_LINKER_FLAGS_RELEASE:STRING= + +//Flags used by the linker during the creation of static libraries +// during RELWITHDEBINFO builds. +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO:STRING= + +//Path to a program. +CMAKE_STRIP:FILEPATH=/Library/Developer/CommandLineTools/usr/bin/strip + +//If this value is on, makefiles will be generated without the +// .SILENT directive, and all commands will be echoed to the console +// during the make. This is useful for debugging only. With Visual +// Studio IDE projects all commands are done without /nologo. +CMAKE_VERBOSE_MAKEFILE:BOOL=FALSE + +//Force new FindPython +PYBIND11_FINDPYTHON:BOOL=OFF + +//Install pybind11 header files? +PYBIND11_INSTALL:BOOL=OFF + +//Override the ABI version, may be used to enable the unstable +// ABI. +PYBIND11_INTERNALS_VERSION:STRING= + +//Disable search for Python +PYBIND11_NOPYTHON:BOOL=OFF + +//Use simpler GIL management logic that does not support disassociation +PYBIND11_SIMPLE_GIL_MANAGEMENT:BOOL=OFF + +//Build pybind11 test suite? +PYBIND11_TEST:BOOL=OFF + +//Value Computed by CMake +mcts_alphazero_BINARY_DIR:STATIC=/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build + +//Value Computed by CMake +mcts_alphazero_SOURCE_DIR:STATIC=/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero + +//Value Computed by CMake +pybind11_BINARY_DIR:STATIC=/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/pybind11 + +//Value Computed by CMake +pybind11_SOURCE_DIR:STATIC=/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/pybind11 + + +######################## +# INTERNAL cache entries +######################## + +//ADVANCED property for variable: CMAKE_ADDR2LINE +CMAKE_ADDR2LINE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_AR +CMAKE_AR-ADVANCED:INTERNAL=1 +//This is the directory where this CMakeCache.txt was created +CMAKE_CACHEFILE_DIR:INTERNAL=/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build +//Major version of cmake used to create the current loaded cache +CMAKE_CACHE_MAJOR_VERSION:INTERNAL=3 +//Minor version of cmake used to create the current loaded cache +CMAKE_CACHE_MINOR_VERSION:INTERNAL=18 +//Patch version of cmake used to create the current loaded cache +CMAKE_CACHE_PATCH_VERSION:INTERNAL=4 +//ADVANCED property for variable: CMAKE_COLOR_MAKEFILE +CMAKE_COLOR_MAKEFILE-ADVANCED:INTERNAL=1 +//Path to CMake executable. +CMAKE_COMMAND:INTERNAL=/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/bin/cmake +//Path to cpack program executable. +CMAKE_CPACK_COMMAND:INTERNAL=/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/bin/cpack +//Path to ctest program executable. +CMAKE_CTEST_COMMAND:INTERNAL=/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/bin/ctest +//ADVANCED property for variable: CMAKE_CXX_COMPILER +CMAKE_CXX_COMPILER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS +CMAKE_CXX_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_DEBUG +CMAKE_CXX_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_MINSIZEREL +CMAKE_CXX_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELEASE +CMAKE_CXX_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_CXX_FLAGS_RELWITHDEBINFO +CMAKE_CXX_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_COMPILER +CMAKE_C_COMPILER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_FLAGS +CMAKE_C_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_FLAGS_DEBUG +CMAKE_C_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_FLAGS_MINSIZEREL +CMAKE_C_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_FLAGS_RELEASE +CMAKE_C_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_C_FLAGS_RELWITHDEBINFO +CMAKE_C_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_DLLTOOL +CMAKE_DLLTOOL-ADVANCED:INTERNAL=1 +//Path to cache edit program executable. +CMAKE_EDIT_COMMAND:INTERNAL=/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/bin/ccmake +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS +CMAKE_EXE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_DEBUG +CMAKE_EXE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_MINSIZEREL +CMAKE_EXE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELEASE +CMAKE_EXE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_EXE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_EXPORT_COMPILE_COMMANDS +CMAKE_EXPORT_COMPILE_COMMANDS-ADVANCED:INTERNAL=1 +//Name of external makefile project generator. +CMAKE_EXTRA_GENERATOR:INTERNAL= +//Name of generator. +CMAKE_GENERATOR:INTERNAL=Unix Makefiles +//Generator instance identifier. +CMAKE_GENERATOR_INSTANCE:INTERNAL= +//Name of generator platform. +CMAKE_GENERATOR_PLATFORM:INTERNAL= +//Name of generator toolset. +CMAKE_GENERATOR_TOOLSET:INTERNAL= +//Source directory with the top level CMakeLists.txt file for this +// project +CMAKE_HOME_DIRECTORY:INTERNAL=/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero +//ADVANCED property for variable: CMAKE_INSTALL_BINDIR +CMAKE_INSTALL_BINDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_DATADIR +CMAKE_INSTALL_DATADIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_DATAROOTDIR +CMAKE_INSTALL_DATAROOTDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_DOCDIR +CMAKE_INSTALL_DOCDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_INCLUDEDIR +CMAKE_INSTALL_INCLUDEDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_INFODIR +CMAKE_INSTALL_INFODIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_LIBDIR +CMAKE_INSTALL_LIBDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_LIBEXECDIR +CMAKE_INSTALL_LIBEXECDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_LOCALEDIR +CMAKE_INSTALL_LOCALEDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_LOCALSTATEDIR +CMAKE_INSTALL_LOCALSTATEDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_MANDIR +CMAKE_INSTALL_MANDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_NAME_TOOL +CMAKE_INSTALL_NAME_TOOL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_OLDINCLUDEDIR +CMAKE_INSTALL_OLDINCLUDEDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_RUNSTATEDIR +CMAKE_INSTALL_RUNSTATEDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_SBINDIR +CMAKE_INSTALL_SBINDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_SHAREDSTATEDIR +CMAKE_INSTALL_SHAREDSTATEDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_INSTALL_SYSCONFDIR +CMAKE_INSTALL_SYSCONFDIR-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_LINKER +CMAKE_LINKER-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MAKE_PROGRAM +CMAKE_MAKE_PROGRAM-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS +CMAKE_MODULE_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_DEBUG +CMAKE_MODULE_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL +CMAKE_MODULE_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELEASE +CMAKE_MODULE_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_MODULE_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_NM +CMAKE_NM-ADVANCED:INTERNAL=1 +//number of local generators +CMAKE_NUMBER_OF_MAKEFILES:INTERNAL=2 +//ADVANCED property for variable: CMAKE_OBJCOPY +CMAKE_OBJCOPY-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_OBJDUMP +CMAKE_OBJDUMP-ADVANCED:INTERNAL=1 +//Platform information initialized +CMAKE_PLATFORM_INFO_INITIALIZED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_RANLIB +CMAKE_RANLIB-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_READELF +CMAKE_READELF-ADVANCED:INTERNAL=1 +//Path to CMake installation. +CMAKE_ROOT:INTERNAL=/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS +CMAKE_SHARED_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_DEBUG +CMAKE_SHARED_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL +CMAKE_SHARED_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELEASE +CMAKE_SHARED_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_SHARED_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SKIP_INSTALL_RPATH +CMAKE_SKIP_INSTALL_RPATH-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_SKIP_RPATH +CMAKE_SKIP_RPATH-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS +CMAKE_STATIC_LINKER_FLAGS-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_DEBUG +CMAKE_STATIC_LINKER_FLAGS_DEBUG-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL +CMAKE_STATIC_LINKER_FLAGS_MINSIZEREL-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELEASE +CMAKE_STATIC_LINKER_FLAGS_RELEASE-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO +CMAKE_STATIC_LINKER_FLAGS_RELWITHDEBINFO-ADVANCED:INTERNAL=1 +//ADVANCED property for variable: CMAKE_STRIP +CMAKE_STRIP-ADVANCED:INTERNAL=1 +//uname command +CMAKE_UNAME:INTERNAL=/usr/bin/uname +//ADVANCED property for variable: CMAKE_VERBOSE_MAKEFILE +CMAKE_VERBOSE_MAKEFILE-ADVANCED:INTERNAL=1 +//Details about finding Python3 +FIND_PACKAGE_MESSAGE_DETAILS_Python3:INTERNAL=[/Users/puyuan/opt/anaconda3/bin/python3.8][/Users/puyuan/opt/anaconda3/include/python3.8][/Users/puyuan/opt/anaconda3/lib/libpython3.8.dylib][cfound components: Interpreter Development Development.Module Development.Embed ][v3.8.8()] +//Test HAS_FLTO +HAS_FLTO:INTERNAL=1 +//Test HAS_FLTO_THIN +HAS_FLTO_THIN:INTERNAL=1 +PYBIND11_INCLUDE_DIR:INTERNAL=/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/pybind11/include +//Python executable during the last CMake run +PYBIND11_PYTHON_EXECUTABLE_LAST:INTERNAL=/Users/puyuan/opt/anaconda3/bin/python3.8 +//Python debug status +PYTHON_IS_DEBUG:INTERNAL=0 +PYTHON_MODULE_EXTENSION:INTERNAL=.cpython-38-darwin.so +//CMAKE_INSTALL_PREFIX during last run +_GNUInstallDirs_LAST_CMAKE_INSTALL_PREFIX:INTERNAL=/usr/local +_Python:INTERNAL=Python3 +_Python3_DEVELOPMENT_EMBED_SIGNATURE:INTERNAL=d27edd82a9ed1d6d7d963f856bf8291a +_Python3_DEVELOPMENT_MODULE_SIGNATURE:INTERNAL=f7f84548e45e71ae65b7c5b4fbe49eaf +//Path to a program. +_Python3_EXECUTABLE:INTERNAL=/Users/puyuan/opt/anaconda3/bin/python3.8 +//Path to a file. +_Python3_INCLUDE_DIR:INTERNAL=/Users/puyuan/opt/anaconda3/include/python3.8 +//Python3 Properties +_Python3_INTERPRETER_PROPERTIES:INTERNAL=Python;3;8;8;64;;cpython-38-darwin;/Users/puyuan/opt/anaconda3/lib/python3.8;/Users/puyuan/opt/anaconda3/lib/python3.8;/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages;/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages +_Python3_INTERPRETER_SIGNATURE:INTERNAL=c1b430249a196e73daf384c69ff3d634 +//Path to a library. +_Python3_LIBRARY_RELEASE:INTERNAL=/Users/puyuan/opt/anaconda3/lib/libpython3.8.dylib +//True if pybind11 and all required components found on the system +pybind11_FOUND:INTERNAL=TRUE +//Directory where pybind11 headers are located +pybind11_INCLUDE_DIR:INTERNAL=/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/pybind11/include +//Directories where pybind11 and possibly Python headers are located +pybind11_INCLUDE_DIRS:INTERNAL=/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/pybind11/include;/Users/puyuan/opt/anaconda3/include/python3.8 + diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CMakeCCompiler.cmake b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CMakeCCompiler.cmake new file mode 100755 index 000000000..81c51cb45 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CMakeCCompiler.cmake @@ -0,0 +1,77 @@ +set(CMAKE_C_COMPILER "/Library/Developer/CommandLineTools/usr/bin/cc") +set(CMAKE_C_COMPILER_ARG1 "") +set(CMAKE_C_COMPILER_ID "AppleClang") +set(CMAKE_C_COMPILER_VERSION "13.1.6.13160021") +set(CMAKE_C_COMPILER_VERSION_INTERNAL "") +set(CMAKE_C_COMPILER_WRAPPER "") +set(CMAKE_C_STANDARD_COMPUTED_DEFAULT "11") +set(CMAKE_C_COMPILE_FEATURES "c_std_90;c_function_prototypes;c_std_99;c_restrict;c_variadic_macros;c_std_11;c_static_assert") +set(CMAKE_C90_COMPILE_FEATURES "c_std_90;c_function_prototypes") +set(CMAKE_C99_COMPILE_FEATURES "c_std_99;c_restrict;c_variadic_macros") +set(CMAKE_C11_COMPILE_FEATURES "c_std_11;c_static_assert") + +set(CMAKE_C_PLATFORM_ID "Darwin") +set(CMAKE_C_SIMULATE_ID "") +set(CMAKE_C_COMPILER_FRONTEND_VARIANT "") +set(CMAKE_C_SIMULATE_VERSION "") + + + + +set(CMAKE_AR "/Library/Developer/CommandLineTools/usr/bin/ar") +set(CMAKE_C_COMPILER_AR "") +set(CMAKE_RANLIB "/Library/Developer/CommandLineTools/usr/bin/ranlib") +set(CMAKE_C_COMPILER_RANLIB "") +set(CMAKE_LINKER "/Library/Developer/CommandLineTools/usr/bin/ld") +set(CMAKE_MT "") +set(CMAKE_COMPILER_IS_GNUCC ) +set(CMAKE_C_COMPILER_LOADED 1) +set(CMAKE_C_COMPILER_WORKS TRUE) +set(CMAKE_C_ABI_COMPILED TRUE) +set(CMAKE_COMPILER_IS_MINGW ) +set(CMAKE_COMPILER_IS_CYGWIN ) +if(CMAKE_COMPILER_IS_CYGWIN) + set(CYGWIN 1) + set(UNIX 1) +endif() + +set(CMAKE_C_COMPILER_ENV_VAR "CC") + +if(CMAKE_COMPILER_IS_MINGW) + set(MINGW 1) +endif() +set(CMAKE_C_COMPILER_ID_RUN 1) +set(CMAKE_C_SOURCE_FILE_EXTENSIONS c;m) +set(CMAKE_C_IGNORE_EXTENSIONS h;H;o;O;obj;OBJ;def;DEF;rc;RC) +set(CMAKE_C_LINKER_PREFERENCE 10) + +# Save compiler ABI information. +set(CMAKE_C_SIZEOF_DATA_PTR "8") +set(CMAKE_C_COMPILER_ABI "") +set(CMAKE_C_LIBRARY_ARCHITECTURE "") + +if(CMAKE_C_SIZEOF_DATA_PTR) + set(CMAKE_SIZEOF_VOID_P "${CMAKE_C_SIZEOF_DATA_PTR}") +endif() + +if(CMAKE_C_COMPILER_ABI) + set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_C_COMPILER_ABI}") +endif() + +if(CMAKE_C_LIBRARY_ARCHITECTURE) + set(CMAKE_LIBRARY_ARCHITECTURE "") +endif() + +set(CMAKE_C_CL_SHOWINCLUDES_PREFIX "") +if(CMAKE_C_CL_SHOWINCLUDES_PREFIX) + set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_C_CL_SHOWINCLUDES_PREFIX}") +endif() + + + + + +set(CMAKE_C_IMPLICIT_INCLUDE_DIRECTORIES "/Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/include;/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include;/Library/Developer/CommandLineTools/usr/include") +set(CMAKE_C_IMPLICIT_LINK_LIBRARIES "") +set(CMAKE_C_IMPLICIT_LINK_DIRECTORIES "/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/lib") +set(CMAKE_C_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/System/Library/Frameworks") diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CMakeCXXCompiler.cmake b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CMakeCXXCompiler.cmake new file mode 100755 index 000000000..ba031ac92 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CMakeCXXCompiler.cmake @@ -0,0 +1,89 @@ +set(CMAKE_CXX_COMPILER "/Library/Developer/CommandLineTools/usr/bin/c++") +set(CMAKE_CXX_COMPILER_ARG1 "") +set(CMAKE_CXX_COMPILER_ID "AppleClang") +set(CMAKE_CXX_COMPILER_VERSION "13.1.6.13160021") +set(CMAKE_CXX_COMPILER_VERSION_INTERNAL "") +set(CMAKE_CXX_COMPILER_WRAPPER "") +set(CMAKE_CXX_STANDARD_COMPUTED_DEFAULT "98") +set(CMAKE_CXX_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters;cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates;cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates;cxx_std_17;cxx_std_20") +set(CMAKE_CXX98_COMPILE_FEATURES "cxx_std_98;cxx_template_template_parameters") +set(CMAKE_CXX11_COMPILE_FEATURES "cxx_std_11;cxx_alias_templates;cxx_alignas;cxx_alignof;cxx_attributes;cxx_auto_type;cxx_constexpr;cxx_decltype;cxx_decltype_incomplete_return_types;cxx_default_function_template_args;cxx_defaulted_functions;cxx_defaulted_move_initializers;cxx_delegating_constructors;cxx_deleted_functions;cxx_enum_forward_declarations;cxx_explicit_conversions;cxx_extended_friend_declarations;cxx_extern_templates;cxx_final;cxx_func_identifier;cxx_generalized_initializers;cxx_inheriting_constructors;cxx_inline_namespaces;cxx_lambdas;cxx_local_type_template_args;cxx_long_long_type;cxx_noexcept;cxx_nonstatic_member_init;cxx_nullptr;cxx_override;cxx_range_for;cxx_raw_string_literals;cxx_reference_qualified_functions;cxx_right_angle_brackets;cxx_rvalue_references;cxx_sizeof_member;cxx_static_assert;cxx_strong_enums;cxx_thread_local;cxx_trailing_return_types;cxx_unicode_literals;cxx_uniform_initialization;cxx_unrestricted_unions;cxx_user_literals;cxx_variadic_macros;cxx_variadic_templates") +set(CMAKE_CXX14_COMPILE_FEATURES "cxx_std_14;cxx_aggregate_default_initializers;cxx_attribute_deprecated;cxx_binary_literals;cxx_contextual_conversions;cxx_decltype_auto;cxx_digit_separators;cxx_generic_lambdas;cxx_lambda_init_captures;cxx_relaxed_constexpr;cxx_return_type_deduction;cxx_variable_templates") +set(CMAKE_CXX17_COMPILE_FEATURES "cxx_std_17") +set(CMAKE_CXX20_COMPILE_FEATURES "cxx_std_20") + +set(CMAKE_CXX_PLATFORM_ID "Darwin") +set(CMAKE_CXX_SIMULATE_ID "") +set(CMAKE_CXX_COMPILER_FRONTEND_VARIANT "") +set(CMAKE_CXX_SIMULATE_VERSION "") + + + + +set(CMAKE_AR "/Library/Developer/CommandLineTools/usr/bin/ar") +set(CMAKE_CXX_COMPILER_AR "") +set(CMAKE_RANLIB "/Library/Developer/CommandLineTools/usr/bin/ranlib") +set(CMAKE_CXX_COMPILER_RANLIB "") +set(CMAKE_LINKER "/Library/Developer/CommandLineTools/usr/bin/ld") +set(CMAKE_MT "") +set(CMAKE_COMPILER_IS_GNUCXX ) +set(CMAKE_CXX_COMPILER_LOADED 1) +set(CMAKE_CXX_COMPILER_WORKS TRUE) +set(CMAKE_CXX_ABI_COMPILED TRUE) +set(CMAKE_COMPILER_IS_MINGW ) +set(CMAKE_COMPILER_IS_CYGWIN ) +if(CMAKE_COMPILER_IS_CYGWIN) + set(CYGWIN 1) + set(UNIX 1) +endif() + +set(CMAKE_CXX_COMPILER_ENV_VAR "CXX") + +if(CMAKE_COMPILER_IS_MINGW) + set(MINGW 1) +endif() +set(CMAKE_CXX_COMPILER_ID_RUN 1) +set(CMAKE_CXX_SOURCE_FILE_EXTENSIONS C;M;c++;cc;cpp;cxx;m;mm;CPP) +set(CMAKE_CXX_IGNORE_EXTENSIONS inl;h;hpp;HPP;H;o;O;obj;OBJ;def;DEF;rc;RC) + +foreach (lang C OBJC OBJCXX) + if (CMAKE_${lang}_COMPILER_ID_RUN) + foreach(extension IN LISTS CMAKE_${lang}_SOURCE_FILE_EXTENSIONS) + list(REMOVE_ITEM CMAKE_CXX_SOURCE_FILE_EXTENSIONS ${extension}) + endforeach() + endif() +endforeach() + +set(CMAKE_CXX_LINKER_PREFERENCE 30) +set(CMAKE_CXX_LINKER_PREFERENCE_PROPAGATES 1) + +# Save compiler ABI information. +set(CMAKE_CXX_SIZEOF_DATA_PTR "8") +set(CMAKE_CXX_COMPILER_ABI "") +set(CMAKE_CXX_LIBRARY_ARCHITECTURE "") + +if(CMAKE_CXX_SIZEOF_DATA_PTR) + set(CMAKE_SIZEOF_VOID_P "${CMAKE_CXX_SIZEOF_DATA_PTR}") +endif() + +if(CMAKE_CXX_COMPILER_ABI) + set(CMAKE_INTERNAL_PLATFORM_ABI "${CMAKE_CXX_COMPILER_ABI}") +endif() + +if(CMAKE_CXX_LIBRARY_ARCHITECTURE) + set(CMAKE_LIBRARY_ARCHITECTURE "") +endif() + +set(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX "") +if(CMAKE_CXX_CL_SHOWINCLUDES_PREFIX) + set(CMAKE_CL_SHOWINCLUDES_PREFIX "${CMAKE_CXX_CL_SHOWINCLUDES_PREFIX}") +endif() + + + + + +set(CMAKE_CXX_IMPLICIT_INCLUDE_DIRECTORIES "/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include/c++/v1;/Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/include;/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include;/Library/Developer/CommandLineTools/usr/include") +set(CMAKE_CXX_IMPLICIT_LINK_LIBRARIES "c++") +set(CMAKE_CXX_IMPLICIT_LINK_DIRECTORIES "/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/lib") +set(CMAKE_CXX_IMPLICIT_LINK_FRAMEWORK_DIRECTORIES "/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/System/Library/Frameworks") diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CMakeDetermineCompilerABI_C.bin b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CMakeDetermineCompilerABI_C.bin new file mode 100755 index 0000000000000000000000000000000000000000..b9458ad5e965a88ba3117186dda3dc2c7d3d8d60 GIT binary patch literal 16592 zcmeI3%WD%+6vl6w1_Kt`jbf=_a3Sg--+i1p_cyaWAGW^!++j>C zZj2d%?}BF`9+?y(W5(fmxV6PI7o3~U)fvu4Ef$r3Rm_vcMr&uC8?(_Z-uYZ~&ICGv zX*%npS=)A(+kWipXujL0aTzR31zV_x2iqxD!_wMvquv@M{Jp;QAm8rb5OpM9I2mGV zJN3KOdc{`j3k^?4>w6jGBU2hRx&O-s{4W=#FFEH5eRetjo_$XJ@nevP3_PxZK48r1 zWDsvV;PgA#8kZ z7S1)^IbPY1&n-5n1@&B8X|>&2`fM6?RZG|eI|yg~e9o98#>0UoFPR94fCz|y2#A0P zh=2%)fCz|y2#A0Ph=2%)fCz|y2#A0Ph=2%)fCz|y2#A0Ph=2%)fCz|y2#A0Ph=2%) zfCz|y2#A0Ph=2%)fCz|y2#A0Ph=2%)!2e0$dcON*!}-DDy7xEp-OjfSr$?19U)jt* zN$f*7`ery8cY0l?_t@#pyhU8_rT%a_ug~QJ@=W}o{w8!f9y~y zmQYH?#Z%%{5sy?_W=icBFN$kDd+C}nZ`_!{YSdy;`CElNc?r~d&bU1n4ROyGqHD_6 z1F{T9eK4&ZtK)ccPe=3JxhRj3jWd1-bg~}~u@;tER~q$JKjE+Sz3}sm`iGz+`NGL$ zu64V9&#s%=t}i!S9j)(;pASr7(BS?j>+_!~O-~vVrGQ<*duPBY7~lJez`*6|>my37 z<^1_yhk{awLrwd{^P=(Ij*O^zr}(TmEVu))_&(wLu>UVMEJ11UA@OXx)y%Hg<*d27 zVv2?x5Jw#wh2-lm6Bk~-y0XjKcslv^w5+AYy*uS}V#u9)|H)STr0k7|2X=hc>Roa$Vf4C2@3GNa{O~MnrRl3P=UeuDtFf%j zyH0ZwO53q? z)mk#GraD|(vg_)o*WCT-p&PDLFgYc9SoVVcc!Z^5UdJ_R+v94lmY`M{5$0N2I_0196N$8%i~s-t literal 0 HcmV?d00001 diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CMakeSystem.cmake b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CMakeSystem.cmake new file mode 100755 index 000000000..085a403d1 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CMakeSystem.cmake @@ -0,0 +1,15 @@ +set(CMAKE_HOST_SYSTEM "Darwin-21.4.0") +set(CMAKE_HOST_SYSTEM_NAME "Darwin") +set(CMAKE_HOST_SYSTEM_VERSION "21.4.0") +set(CMAKE_HOST_SYSTEM_PROCESSOR "x86_64") + + + +set(CMAKE_SYSTEM "Darwin-21.4.0") +set(CMAKE_SYSTEM_NAME "Darwin") +set(CMAKE_SYSTEM_VERSION "21.4.0") +set(CMAKE_SYSTEM_PROCESSOR "x86_64") + +set(CMAKE_CROSSCOMPILING "FALSE") + +set(CMAKE_SYSTEM_LOADED 1) diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CompilerIdC/CMakeCCompilerId.c b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CompilerIdC/CMakeCCompilerId.c new file mode 100644 index 000000000..6c0aa93cb --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CompilerIdC/CMakeCCompilerId.c @@ -0,0 +1,674 @@ +#ifdef __cplusplus +# error "A C++ compiler has been selected for C." +#endif + +#if defined(__18CXX) +# define ID_VOID_MAIN +#endif +#if defined(__CLASSIC_C__) +/* cv-qualifiers did not exist in K&R C */ +# define const +# define volatile +#endif + + +/* Version number components: V=Version, R=Revision, P=Patch + Version date components: YYYY=Year, MM=Month, DD=Day */ + +#if defined(__INTEL_COMPILER) || defined(__ICC) +# define COMPILER_ID "Intel" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# if defined(__GNUC__) +# define SIMULATE_ID "GNU" +# endif + /* __INTEL_COMPILER = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__INTEL_COMPILER/100) +# define COMPILER_VERSION_MINOR DEC(__INTEL_COMPILER/10 % 10) +# if defined(__INTEL_COMPILER_UPDATE) +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER_UPDATE) +# else +# define COMPILER_VERSION_PATCH DEC(__INTEL_COMPILER % 10) +# endif +# if defined(__INTEL_COMPILER_BUILD_DATE) + /* __INTEL_COMPILER_BUILD_DATE = YYYYMMDD */ +# define COMPILER_VERSION_TWEAK DEC(__INTEL_COMPILER_BUILD_DATE) +# endif +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# if defined(__GNUC__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUC__) +# elif defined(__GNUG__) +# define SIMULATE_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define SIMULATE_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define SIMULATE_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(__PATHCC__) +# define COMPILER_ID "PathScale" +# define COMPILER_VERSION_MAJOR DEC(__PATHCC__) +# define COMPILER_VERSION_MINOR DEC(__PATHCC_MINOR__) +# if defined(__PATHCC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PATHCC_PATCHLEVEL__) +# endif + +#elif defined(__BORLANDC__) && defined(__CODEGEARC_VERSION__) +# define COMPILER_ID "Embarcadero" +# define COMPILER_VERSION_MAJOR HEX(__CODEGEARC_VERSION__>>24 & 0x00FF) +# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF) +# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF) + +#elif defined(__BORLANDC__) +# define COMPILER_ID "Borland" + /* __BORLANDC__ = 0xVRR */ +# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8) +# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF) + +#elif defined(__WATCOMC__) && __WATCOMC__ < 1200 +# define COMPILER_ID "Watcom" + /* __WATCOMC__ = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__WATCOMC__) +# define COMPILER_ID "OpenWatcom" + /* __WATCOMC__ = VVRP + 1100 */ +# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__SUNPRO_C) +# define COMPILER_ID "SunPro" +# if __SUNPRO_C >= 0x5100 + /* __SUNPRO_C = 0xVRRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>12) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_C & 0xF) +# else + /* __SUNPRO_CC = 0xVRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_C>>8) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_C>>4 & 0xF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_C & 0xF) +# endif + +#elif defined(__HP_cc) +# define COMPILER_ID "HP" + /* __HP_cc = VVRRPP */ +# define COMPILER_VERSION_MAJOR DEC(__HP_cc/10000) +# define COMPILER_VERSION_MINOR DEC(__HP_cc/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__HP_cc % 100) + +#elif defined(__DECC) +# define COMPILER_ID "Compaq" + /* __DECC_VER = VVRRTPPPP */ +# define COMPILER_VERSION_MAJOR DEC(__DECC_VER/10000000) +# define COMPILER_VERSION_MINOR DEC(__DECC_VER/100000 % 100) +# define COMPILER_VERSION_PATCH DEC(__DECC_VER % 10000) + +#elif defined(__IBMC__) && defined(__COMPILER_VER__) +# define COMPILER_ID "zOS" + /* __IBMC__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10) + +#elif defined(__ibmxl__) && defined(__clang__) +# define COMPILER_ID "XLClang" +# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__) +# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__) +# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__) +# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__) + + +#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ >= 800 +# define COMPILER_ID "XL" + /* __IBMC__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10) + +#elif defined(__IBMC__) && !defined(__COMPILER_VER__) && __IBMC__ < 800 +# define COMPILER_ID "VisualAge" + /* __IBMC__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMC__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMC__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMC__ % 10) + +#elif defined(__PGI) +# define COMPILER_ID "PGI" +# define COMPILER_VERSION_MAJOR DEC(__PGIC__) +# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__) +# if defined(__PGIC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__) +# endif + +#elif defined(_CRAYC) +# define COMPILER_ID "Cray" +# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR) +# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR) + +#elif defined(__TI_COMPILER_VERSION__) +# define COMPILER_ID "TI" + /* __TI_COMPILER_VERSION__ = VVVRRRPPP */ +# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000) +# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000) +# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000) + +#elif defined(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version) +# define COMPILER_ID "Fujitsu" + +#elif defined(__ghs__) +# define COMPILER_ID "GHS" +/* __GHS_VERSION_NUMBER = VVVVRP */ +# ifdef __GHS_VERSION_NUMBER +# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100) +# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10) +# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER % 10) +# endif + +#elif defined(__TINYC__) +# define COMPILER_ID "TinyCC" + +#elif defined(__BCC__) +# define COMPILER_ID "Bruce" + +#elif defined(__SCO_VERSION__) +# define COMPILER_ID "SCO" + +#elif defined(__ARMCC_VERSION) && !defined(__clang__) +# define COMPILER_ID "ARMCC" +#if __ARMCC_VERSION >= 1000000 + /* __ARMCC_VERSION = VRRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#else + /* __ARMCC_VERSION = VRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#endif + + +#elif defined(__clang__) && defined(__apple_build_version__) +# define COMPILER_ID "AppleClang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__) + +#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION) +# define COMPILER_ID "ARMClang" + # define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION % 10000) +# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION) + +#elif defined(__clang__) +# define COMPILER_ID "Clang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + +#elif defined(__GNUC__) +# define COMPILER_ID "GNU" +# define COMPILER_VERSION_MAJOR DEC(__GNUC__) +# if defined(__GNUC_MINOR__) +# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(_MSC_VER) +# define COMPILER_ID "MSVC" + /* _MSC_VER = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100) +# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100) +# if defined(_MSC_FULL_VER) +# if _MSC_VER >= 1400 + /* _MSC_FULL_VER = VVRRPPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000) +# else + /* _MSC_FULL_VER = VVRRPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000) +# endif +# endif +# if defined(_MSC_BUILD) +# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD) +# endif + +#elif defined(__VISUALDSPVERSION__) || defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__) +# define COMPILER_ID "ADSP" +#if defined(__VISUALDSPVERSION__) + /* __VISUALDSPVERSION__ = 0xVVRRPP00 */ +# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24) +# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8 & 0xFF) +#endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# define COMPILER_ID "IAR" +# if defined(__VER__) && defined(__ICCARM__) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000) +# define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000) +# define COMPILER_VERSION_PATCH DEC((__VER__) % 1000) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__)) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 100) +# define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100)) +# define COMPILER_VERSION_PATCH DEC(__SUBVERSION__) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# endif + +#elif defined(__SDCC_VERSION_MAJOR) || defined(SDCC) +# define COMPILER_ID "SDCC" +# if defined(__SDCC_VERSION_MAJOR) +# define COMPILER_VERSION_MAJOR DEC(__SDCC_VERSION_MAJOR) +# define COMPILER_VERSION_MINOR DEC(__SDCC_VERSION_MINOR) +# define COMPILER_VERSION_PATCH DEC(__SDCC_VERSION_PATCH) +# else + /* SDCC = VRP */ +# define COMPILER_VERSION_MAJOR DEC(SDCC/100) +# define COMPILER_VERSION_MINOR DEC(SDCC/10 % 10) +# define COMPILER_VERSION_PATCH DEC(SDCC % 10) +# endif + + +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__hpux) || defined(__hpua) +# define COMPILER_ID "HP" + +#else /* unknown compiler */ +# define COMPILER_ID "" +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#ifdef __QNXNTO__ +char const* qnxnto = "INFO" ":" "qnxnto[]"; +#endif + +#if defined(__CRAYXE) || defined(__CRAYXC) +char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]"; +#endif + +#define STRINGIFY_HELPER(X) #X +#define STRINGIFY(X) STRINGIFY_HELPER(X) + +/* Identify known platforms by name. */ +#if defined(__linux) || defined(__linux__) || defined(linux) +# define PLATFORM_ID "Linux" + +#elif defined(__CYGWIN__) +# define PLATFORM_ID "Cygwin" + +#elif defined(__MINGW32__) +# define PLATFORM_ID "MinGW" + +#elif defined(__APPLE__) +# define PLATFORM_ID "Darwin" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +# define PLATFORM_ID "Windows" + +#elif defined(__FreeBSD__) || defined(__FreeBSD) +# define PLATFORM_ID "FreeBSD" + +#elif defined(__NetBSD__) || defined(__NetBSD) +# define PLATFORM_ID "NetBSD" + +#elif defined(__OpenBSD__) || defined(__OPENBSD) +# define PLATFORM_ID "OpenBSD" + +#elif defined(__sun) || defined(sun) +# define PLATFORM_ID "SunOS" + +#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__) +# define PLATFORM_ID "AIX" + +#elif defined(__hpux) || defined(__hpux__) +# define PLATFORM_ID "HP-UX" + +#elif defined(__HAIKU__) +# define PLATFORM_ID "Haiku" + +#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS) +# define PLATFORM_ID "BeOS" + +#elif defined(__QNX__) || defined(__QNXNTO__) +# define PLATFORM_ID "QNX" + +#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__) +# define PLATFORM_ID "Tru64" + +#elif defined(__riscos) || defined(__riscos__) +# define PLATFORM_ID "RISCos" + +#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__) +# define PLATFORM_ID "SINIX" + +#elif defined(__UNIX_SV__) +# define PLATFORM_ID "UNIX_SV" + +#elif defined(__bsdos__) +# define PLATFORM_ID "BSDOS" + +#elif defined(_MPRAS) || defined(MPRAS) +# define PLATFORM_ID "MP-RAS" + +#elif defined(__osf) || defined(__osf__) +# define PLATFORM_ID "OSF1" + +#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv) +# define PLATFORM_ID "SCO_SV" + +#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX) +# define PLATFORM_ID "ULTRIX" + +#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX) +# define PLATFORM_ID "Xenix" + +#elif defined(__WATCOMC__) +# if defined(__LINUX__) +# define PLATFORM_ID "Linux" + +# elif defined(__DOS__) +# define PLATFORM_ID "DOS" + +# elif defined(__OS2__) +# define PLATFORM_ID "OS2" + +# elif defined(__WINDOWS__) +# define PLATFORM_ID "Windows3x" + +# elif defined(__VXWORKS__) +# define PLATFORM_ID "VxWorks" + +# else /* unknown platform */ +# define PLATFORM_ID +# endif + +#elif defined(__INTEGRITY) +# if defined(INT_178B) +# define PLATFORM_ID "Integrity178" + +# else /* regular Integrity */ +# define PLATFORM_ID "Integrity" +# endif + +#else /* unknown platform */ +# define PLATFORM_ID + +#endif + +/* For windows compilers MSVC and Intel we can determine + the architecture of the compiler being used. This is because + the compilers do not have flags that can change the architecture, + but rather depend on which compiler is being used +*/ +#if defined(_WIN32) && defined(_MSC_VER) +# if defined(_M_IA64) +# define ARCHITECTURE_ID "IA64" + +# elif defined(_M_X64) || defined(_M_AMD64) +# define ARCHITECTURE_ID "x64" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# elif defined(_M_ARM64) +# define ARCHITECTURE_ID "ARM64" + +# elif defined(_M_ARM) +# if _M_ARM == 4 +# define ARCHITECTURE_ID "ARMV4I" +# elif _M_ARM == 5 +# define ARCHITECTURE_ID "ARMV5I" +# else +# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM) +# endif + +# elif defined(_M_MIPS) +# define ARCHITECTURE_ID "MIPS" + +# elif defined(_M_SH) +# define ARCHITECTURE_ID "SHx" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__WATCOMC__) +# if defined(_M_I86) +# define ARCHITECTURE_ID "I86" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# if defined(__ICCARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__ICCRX__) +# define ARCHITECTURE_ID "RX" + +# elif defined(__ICCRH850__) +# define ARCHITECTURE_ID "RH850" + +# elif defined(__ICCRL78__) +# define ARCHITECTURE_ID "RL78" + +# elif defined(__ICCRISCV__) +# define ARCHITECTURE_ID "RISCV" + +# elif defined(__ICCAVR__) +# define ARCHITECTURE_ID "AVR" + +# elif defined(__ICC430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__ICCV850__) +# define ARCHITECTURE_ID "V850" + +# elif defined(__ICC8051__) +# define ARCHITECTURE_ID "8051" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__ghs__) +# if defined(__PPC64__) +# define ARCHITECTURE_ID "PPC64" + +# elif defined(__ppc__) +# define ARCHITECTURE_ID "PPC" + +# elif defined(__ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__x86_64__) +# define ARCHITECTURE_ID "x64" + +# elif defined(__i386__) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif +#else +# define ARCHITECTURE_ID +#endif + +/* Convert integer to decimal digit literals. */ +#define DEC(n) \ + ('0' + (((n) / 10000000)%10)), \ + ('0' + (((n) / 1000000)%10)), \ + ('0' + (((n) / 100000)%10)), \ + ('0' + (((n) / 10000)%10)), \ + ('0' + (((n) / 1000)%10)), \ + ('0' + (((n) / 100)%10)), \ + ('0' + (((n) / 10)%10)), \ + ('0' + ((n) % 10)) + +/* Convert integer to hex digit literals. */ +#define HEX(n) \ + ('0' + ((n)>>28 & 0xF)), \ + ('0' + ((n)>>24 & 0xF)), \ + ('0' + ((n)>>20 & 0xF)), \ + ('0' + ((n)>>16 & 0xF)), \ + ('0' + ((n)>>12 & 0xF)), \ + ('0' + ((n)>>8 & 0xF)), \ + ('0' + ((n)>>4 & 0xF)), \ + ('0' + ((n) & 0xF)) + +/* Construct a string literal encoding the version number components. */ +#ifdef COMPILER_VERSION_MAJOR +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + COMPILER_VERSION_MAJOR, +# ifdef COMPILER_VERSION_MINOR + '.', COMPILER_VERSION_MINOR, +# ifdef COMPILER_VERSION_PATCH + '.', COMPILER_VERSION_PATCH, +# ifdef COMPILER_VERSION_TWEAK + '.', COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct a string literal encoding the internal version number. */ +#ifdef COMPILER_VERSION_INTERNAL +char const info_version_internal[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_', + 'i','n','t','e','r','n','a','l','[', + COMPILER_VERSION_INTERNAL,']','\0'}; +#endif + +/* Construct a string literal encoding the version number components. */ +#ifdef SIMULATE_VERSION_MAJOR +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + SIMULATE_VERSION_MAJOR, +# ifdef SIMULATE_VERSION_MINOR + '.', SIMULATE_VERSION_MINOR, +# ifdef SIMULATE_VERSION_PATCH + '.', SIMULATE_VERSION_PATCH, +# ifdef SIMULATE_VERSION_TWEAK + '.', SIMULATE_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]"; +char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]"; + + + + +#if !defined(__STDC__) +# if (defined(_MSC_VER) && !defined(__clang__)) \ + || (defined(__ibmxl__) || defined(__IBMC__)) +# define C_DIALECT "90" +# else +# define C_DIALECT +# endif +#elif __STDC_VERSION__ >= 201000L +# define C_DIALECT "11" +#elif __STDC_VERSION__ >= 199901L +# define C_DIALECT "99" +#else +# define C_DIALECT "90" +#endif +const char* info_language_dialect_default = + "INFO" ":" "dialect_default[" C_DIALECT "]"; + +/*--------------------------------------------------------------------------*/ + +#ifdef ID_VOID_MAIN +void main() {} +#else +# if defined(__CLASSIC_C__) +int main(argc, argv) int argc; char *argv[]; +# else +int main(int argc, char* argv[]) +# endif +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; + require += info_arch[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#ifdef COMPILER_VERSION_INTERNAL + require += info_version_internal[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#if defined(__CRAYXE) || defined(__CRAYXC) + require += info_cray[argc]; +#endif + require += info_language_dialect_default[argc]; + (void)argv; + return require; +} +#endif diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CompilerIdC/CMakeCCompilerId.o b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CompilerIdC/CMakeCCompilerId.o new file mode 100644 index 0000000000000000000000000000000000000000..d92398cdc9ea9a7767e952e4ff6042349c5fc721 GIT binary patch literal 1400 zcmb7C&ubG=5PoT68nD_NJXA1{gNL4KwuK%Pp&{84L9LV&gb-dI$tGFYY{F(^OF`&K z2}S6iptl~q>B&nE?ahCo7r{e>9)n2ro450tA1La;?94ZB=6myY=JWS&mvchIW(7Xb zIP`c1p9~ao8@fdJ5Av3ZAZMIoFgOKif({{4hR$9X`4KMJ&r2h0yw~gyANA72=NiT0 z;(&}1DXZNuaQy}cq@3h4JllM}Ne>*8=_g59Q=u9qNLk30awB}sZiekK_=xfd{ZXIO zg8tfmcl6-t{`AjA(E~0#1KIC*3@`DuI;tAVp1l7vO<50A%ZUo6``h87b>>@QK8E5tMq_-kE6_z~R5ni`Ep#cxKcb#?VG+aJfknM| z1|1hVH~TUk{}+F|*#B~B|De?V%VDwKyEwH6go=lHeTvm5!-Y@rmDy9zEUIyib#IJtrvVIvvl+d&+NAgg)tbDy+AIR=J=8Op&81s5Z;&*IeZ} zm~zdjtDYB@EvrJW5N4m>X(Yr4wkK>SE|xExpzF5%a#oAAx*R!K%Q$Px)~dCZ&8{## zvs~T7)4vLfTkOX6w?u3&6-&*}C6ADG7x6pLgUg>>24 & 0x00FF) +# define COMPILER_VERSION_MINOR HEX(__CODEGEARC_VERSION__>>16 & 0x00FF) +# define COMPILER_VERSION_PATCH DEC(__CODEGEARC_VERSION__ & 0xFFFF) + +#elif defined(__BORLANDC__) +# define COMPILER_ID "Borland" + /* __BORLANDC__ = 0xVRR */ +# define COMPILER_VERSION_MAJOR HEX(__BORLANDC__>>8) +# define COMPILER_VERSION_MINOR HEX(__BORLANDC__ & 0xFF) + +#elif defined(__WATCOMC__) && __WATCOMC__ < 1200 +# define COMPILER_ID "Watcom" + /* __WATCOMC__ = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(__WATCOMC__ / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__WATCOMC__) +# define COMPILER_ID "OpenWatcom" + /* __WATCOMC__ = VVRP + 1100 */ +# define COMPILER_VERSION_MAJOR DEC((__WATCOMC__ - 1100) / 100) +# define COMPILER_VERSION_MINOR DEC((__WATCOMC__ / 10) % 10) +# if (__WATCOMC__ % 10) > 0 +# define COMPILER_VERSION_PATCH DEC(__WATCOMC__ % 10) +# endif + +#elif defined(__SUNPRO_CC) +# define COMPILER_ID "SunPro" +# if __SUNPRO_CC >= 0x5100 + /* __SUNPRO_CC = 0xVRRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>12) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# else + /* __SUNPRO_CC = 0xVRP */ +# define COMPILER_VERSION_MAJOR HEX(__SUNPRO_CC>>8) +# define COMPILER_VERSION_MINOR HEX(__SUNPRO_CC>>4 & 0xF) +# define COMPILER_VERSION_PATCH HEX(__SUNPRO_CC & 0xF) +# endif + +#elif defined(__HP_aCC) +# define COMPILER_ID "HP" + /* __HP_aCC = VVRRPP */ +# define COMPILER_VERSION_MAJOR DEC(__HP_aCC/10000) +# define COMPILER_VERSION_MINOR DEC(__HP_aCC/100 % 100) +# define COMPILER_VERSION_PATCH DEC(__HP_aCC % 100) + +#elif defined(__DECCXX) +# define COMPILER_ID "Compaq" + /* __DECCXX_VER = VVRRTPPPP */ +# define COMPILER_VERSION_MAJOR DEC(__DECCXX_VER/10000000) +# define COMPILER_VERSION_MINOR DEC(__DECCXX_VER/100000 % 100) +# define COMPILER_VERSION_PATCH DEC(__DECCXX_VER % 10000) + +#elif defined(__IBMCPP__) && defined(__COMPILER_VER__) +# define COMPILER_ID "zOS" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__ibmxl__) && defined(__clang__) +# define COMPILER_ID "XLClang" +# define COMPILER_VERSION_MAJOR DEC(__ibmxl_version__) +# define COMPILER_VERSION_MINOR DEC(__ibmxl_release__) +# define COMPILER_VERSION_PATCH DEC(__ibmxl_modification__) +# define COMPILER_VERSION_TWEAK DEC(__ibmxl_ptf_fix_level__) + + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ >= 800 +# define COMPILER_ID "XL" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__IBMCPP__) && !defined(__COMPILER_VER__) && __IBMCPP__ < 800 +# define COMPILER_ID "VisualAge" + /* __IBMCPP__ = VRP */ +# define COMPILER_VERSION_MAJOR DEC(__IBMCPP__/100) +# define COMPILER_VERSION_MINOR DEC(__IBMCPP__/10 % 10) +# define COMPILER_VERSION_PATCH DEC(__IBMCPP__ % 10) + +#elif defined(__PGI) +# define COMPILER_ID "PGI" +# define COMPILER_VERSION_MAJOR DEC(__PGIC__) +# define COMPILER_VERSION_MINOR DEC(__PGIC_MINOR__) +# if defined(__PGIC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__PGIC_PATCHLEVEL__) +# endif + +#elif defined(_CRAYC) +# define COMPILER_ID "Cray" +# define COMPILER_VERSION_MAJOR DEC(_RELEASE_MAJOR) +# define COMPILER_VERSION_MINOR DEC(_RELEASE_MINOR) + +#elif defined(__TI_COMPILER_VERSION__) +# define COMPILER_ID "TI" + /* __TI_COMPILER_VERSION__ = VVVRRRPPP */ +# define COMPILER_VERSION_MAJOR DEC(__TI_COMPILER_VERSION__/1000000) +# define COMPILER_VERSION_MINOR DEC(__TI_COMPILER_VERSION__/1000 % 1000) +# define COMPILER_VERSION_PATCH DEC(__TI_COMPILER_VERSION__ % 1000) + +#elif defined(__FUJITSU) || defined(__FCC_VERSION) || defined(__fcc_version) +# define COMPILER_ID "Fujitsu" + +#elif defined(__ghs__) +# define COMPILER_ID "GHS" +/* __GHS_VERSION_NUMBER = VVVVRP */ +# ifdef __GHS_VERSION_NUMBER +# define COMPILER_VERSION_MAJOR DEC(__GHS_VERSION_NUMBER / 100) +# define COMPILER_VERSION_MINOR DEC(__GHS_VERSION_NUMBER / 10 % 10) +# define COMPILER_VERSION_PATCH DEC(__GHS_VERSION_NUMBER % 10) +# endif + +#elif defined(__SCO_VERSION__) +# define COMPILER_ID "SCO" + +#elif defined(__ARMCC_VERSION) && !defined(__clang__) +# define COMPILER_ID "ARMCC" +#if __ARMCC_VERSION >= 1000000 + /* __ARMCC_VERSION = VRRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#else + /* __ARMCC_VERSION = VRPPPP */ + # define COMPILER_VERSION_MAJOR DEC(__ARMCC_VERSION/100000) + # define COMPILER_VERSION_MINOR DEC(__ARMCC_VERSION/10000 % 10) + # define COMPILER_VERSION_PATCH DEC(__ARMCC_VERSION % 10000) +#endif + + +#elif defined(__clang__) && defined(__apple_build_version__) +# define COMPILER_ID "AppleClang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif +# define COMPILER_VERSION_TWEAK DEC(__apple_build_version__) + +#elif defined(__clang__) && defined(__ARMCOMPILER_VERSION) +# define COMPILER_ID "ARMClang" + # define COMPILER_VERSION_MAJOR DEC(__ARMCOMPILER_VERSION/1000000) + # define COMPILER_VERSION_MINOR DEC(__ARMCOMPILER_VERSION/10000 % 100) + # define COMPILER_VERSION_PATCH DEC(__ARMCOMPILER_VERSION % 10000) +# define COMPILER_VERSION_INTERNAL DEC(__ARMCOMPILER_VERSION) + +#elif defined(__clang__) +# define COMPILER_ID "Clang" +# if defined(_MSC_VER) +# define SIMULATE_ID "MSVC" +# endif +# define COMPILER_VERSION_MAJOR DEC(__clang_major__) +# define COMPILER_VERSION_MINOR DEC(__clang_minor__) +# define COMPILER_VERSION_PATCH DEC(__clang_patchlevel__) +# if defined(_MSC_VER) + /* _MSC_VER = VVRR */ +# define SIMULATE_VERSION_MAJOR DEC(_MSC_VER / 100) +# define SIMULATE_VERSION_MINOR DEC(_MSC_VER % 100) +# endif + +#elif defined(__GNUC__) || defined(__GNUG__) +# define COMPILER_ID "GNU" +# if defined(__GNUC__) +# define COMPILER_VERSION_MAJOR DEC(__GNUC__) +# else +# define COMPILER_VERSION_MAJOR DEC(__GNUG__) +# endif +# if defined(__GNUC_MINOR__) +# define COMPILER_VERSION_MINOR DEC(__GNUC_MINOR__) +# endif +# if defined(__GNUC_PATCHLEVEL__) +# define COMPILER_VERSION_PATCH DEC(__GNUC_PATCHLEVEL__) +# endif + +#elif defined(_MSC_VER) +# define COMPILER_ID "MSVC" + /* _MSC_VER = VVRR */ +# define COMPILER_VERSION_MAJOR DEC(_MSC_VER / 100) +# define COMPILER_VERSION_MINOR DEC(_MSC_VER % 100) +# if defined(_MSC_FULL_VER) +# if _MSC_VER >= 1400 + /* _MSC_FULL_VER = VVRRPPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 100000) +# else + /* _MSC_FULL_VER = VVRRPPPP */ +# define COMPILER_VERSION_PATCH DEC(_MSC_FULL_VER % 10000) +# endif +# endif +# if defined(_MSC_BUILD) +# define COMPILER_VERSION_TWEAK DEC(_MSC_BUILD) +# endif + +#elif defined(__VISUALDSPVERSION__) || defined(__ADSPBLACKFIN__) || defined(__ADSPTS__) || defined(__ADSP21000__) +# define COMPILER_ID "ADSP" +#if defined(__VISUALDSPVERSION__) + /* __VISUALDSPVERSION__ = 0xVVRRPP00 */ +# define COMPILER_VERSION_MAJOR HEX(__VISUALDSPVERSION__>>24) +# define COMPILER_VERSION_MINOR HEX(__VISUALDSPVERSION__>>16 & 0xFF) +# define COMPILER_VERSION_PATCH HEX(__VISUALDSPVERSION__>>8 & 0xFF) +#endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# define COMPILER_ID "IAR" +# if defined(__VER__) && defined(__ICCARM__) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 1000000) +# define COMPILER_VERSION_MINOR DEC(((__VER__) / 1000) % 1000) +# define COMPILER_VERSION_PATCH DEC((__VER__) % 1000) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# elif defined(__VER__) && (defined(__ICCAVR__) || defined(__ICCRX__) || defined(__ICCRH850__) || defined(__ICCRL78__) || defined(__ICC430__) || defined(__ICCRISCV__) || defined(__ICCV850__) || defined(__ICC8051__)) +# define COMPILER_VERSION_MAJOR DEC((__VER__) / 100) +# define COMPILER_VERSION_MINOR DEC((__VER__) - (((__VER__) / 100)*100)) +# define COMPILER_VERSION_PATCH DEC(__SUBVERSION__) +# define COMPILER_VERSION_INTERNAL DEC(__IAR_SYSTEMS_ICC__) +# endif + + +/* These compilers are either not known or too old to define an + identification macro. Try to identify the platform and guess that + it is the native compiler. */ +#elif defined(__hpux) || defined(__hpua) +# define COMPILER_ID "HP" + +#else /* unknown compiler */ +# define COMPILER_ID "" +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_compiler = "INFO" ":" "compiler[" COMPILER_ID "]"; +#ifdef SIMULATE_ID +char const* info_simulate = "INFO" ":" "simulate[" SIMULATE_ID "]"; +#endif + +#ifdef __QNXNTO__ +char const* qnxnto = "INFO" ":" "qnxnto[]"; +#endif + +#if defined(__CRAYXE) || defined(__CRAYXC) +char const *info_cray = "INFO" ":" "compiler_wrapper[CrayPrgEnv]"; +#endif + +#define STRINGIFY_HELPER(X) #X +#define STRINGIFY(X) STRINGIFY_HELPER(X) + +/* Identify known platforms by name. */ +#if defined(__linux) || defined(__linux__) || defined(linux) +# define PLATFORM_ID "Linux" + +#elif defined(__CYGWIN__) +# define PLATFORM_ID "Cygwin" + +#elif defined(__MINGW32__) +# define PLATFORM_ID "MinGW" + +#elif defined(__APPLE__) +# define PLATFORM_ID "Darwin" + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +# define PLATFORM_ID "Windows" + +#elif defined(__FreeBSD__) || defined(__FreeBSD) +# define PLATFORM_ID "FreeBSD" + +#elif defined(__NetBSD__) || defined(__NetBSD) +# define PLATFORM_ID "NetBSD" + +#elif defined(__OpenBSD__) || defined(__OPENBSD) +# define PLATFORM_ID "OpenBSD" + +#elif defined(__sun) || defined(sun) +# define PLATFORM_ID "SunOS" + +#elif defined(_AIX) || defined(__AIX) || defined(__AIX__) || defined(__aix) || defined(__aix__) +# define PLATFORM_ID "AIX" + +#elif defined(__hpux) || defined(__hpux__) +# define PLATFORM_ID "HP-UX" + +#elif defined(__HAIKU__) +# define PLATFORM_ID "Haiku" + +#elif defined(__BeOS) || defined(__BEOS__) || defined(_BEOS) +# define PLATFORM_ID "BeOS" + +#elif defined(__QNX__) || defined(__QNXNTO__) +# define PLATFORM_ID "QNX" + +#elif defined(__tru64) || defined(_tru64) || defined(__TRU64__) +# define PLATFORM_ID "Tru64" + +#elif defined(__riscos) || defined(__riscos__) +# define PLATFORM_ID "RISCos" + +#elif defined(__sinix) || defined(__sinix__) || defined(__SINIX__) +# define PLATFORM_ID "SINIX" + +#elif defined(__UNIX_SV__) +# define PLATFORM_ID "UNIX_SV" + +#elif defined(__bsdos__) +# define PLATFORM_ID "BSDOS" + +#elif defined(_MPRAS) || defined(MPRAS) +# define PLATFORM_ID "MP-RAS" + +#elif defined(__osf) || defined(__osf__) +# define PLATFORM_ID "OSF1" + +#elif defined(_SCO_SV) || defined(SCO_SV) || defined(sco_sv) +# define PLATFORM_ID "SCO_SV" + +#elif defined(__ultrix) || defined(__ultrix__) || defined(_ULTRIX) +# define PLATFORM_ID "ULTRIX" + +#elif defined(__XENIX__) || defined(_XENIX) || defined(XENIX) +# define PLATFORM_ID "Xenix" + +#elif defined(__WATCOMC__) +# if defined(__LINUX__) +# define PLATFORM_ID "Linux" + +# elif defined(__DOS__) +# define PLATFORM_ID "DOS" + +# elif defined(__OS2__) +# define PLATFORM_ID "OS2" + +# elif defined(__WINDOWS__) +# define PLATFORM_ID "Windows3x" + +# elif defined(__VXWORKS__) +# define PLATFORM_ID "VxWorks" + +# else /* unknown platform */ +# define PLATFORM_ID +# endif + +#elif defined(__INTEGRITY) +# if defined(INT_178B) +# define PLATFORM_ID "Integrity178" + +# else /* regular Integrity */ +# define PLATFORM_ID "Integrity" +# endif + +#else /* unknown platform */ +# define PLATFORM_ID + +#endif + +/* For windows compilers MSVC and Intel we can determine + the architecture of the compiler being used. This is because + the compilers do not have flags that can change the architecture, + but rather depend on which compiler is being used +*/ +#if defined(_WIN32) && defined(_MSC_VER) +# if defined(_M_IA64) +# define ARCHITECTURE_ID "IA64" + +# elif defined(_M_X64) || defined(_M_AMD64) +# define ARCHITECTURE_ID "x64" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# elif defined(_M_ARM64) +# define ARCHITECTURE_ID "ARM64" + +# elif defined(_M_ARM) +# if _M_ARM == 4 +# define ARCHITECTURE_ID "ARMV4I" +# elif _M_ARM == 5 +# define ARCHITECTURE_ID "ARMV5I" +# else +# define ARCHITECTURE_ID "ARMV" STRINGIFY(_M_ARM) +# endif + +# elif defined(_M_MIPS) +# define ARCHITECTURE_ID "MIPS" + +# elif defined(_M_SH) +# define ARCHITECTURE_ID "SHx" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__WATCOMC__) +# if defined(_M_I86) +# define ARCHITECTURE_ID "I86" + +# elif defined(_M_IX86) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__IAR_SYSTEMS_ICC__) || defined(__IAR_SYSTEMS_ICC) +# if defined(__ICCARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__ICCRX__) +# define ARCHITECTURE_ID "RX" + +# elif defined(__ICCRH850__) +# define ARCHITECTURE_ID "RH850" + +# elif defined(__ICCRL78__) +# define ARCHITECTURE_ID "RL78" + +# elif defined(__ICCRISCV__) +# define ARCHITECTURE_ID "RISCV" + +# elif defined(__ICCAVR__) +# define ARCHITECTURE_ID "AVR" + +# elif defined(__ICC430__) +# define ARCHITECTURE_ID "MSP430" + +# elif defined(__ICCV850__) +# define ARCHITECTURE_ID "V850" + +# elif defined(__ICC8051__) +# define ARCHITECTURE_ID "8051" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif + +#elif defined(__ghs__) +# if defined(__PPC64__) +# define ARCHITECTURE_ID "PPC64" + +# elif defined(__ppc__) +# define ARCHITECTURE_ID "PPC" + +# elif defined(__ARM__) +# define ARCHITECTURE_ID "ARM" + +# elif defined(__x86_64__) +# define ARCHITECTURE_ID "x64" + +# elif defined(__i386__) +# define ARCHITECTURE_ID "X86" + +# else /* unknown architecture */ +# define ARCHITECTURE_ID "" +# endif +#else +# define ARCHITECTURE_ID +#endif + +/* Convert integer to decimal digit literals. */ +#define DEC(n) \ + ('0' + (((n) / 10000000)%10)), \ + ('0' + (((n) / 1000000)%10)), \ + ('0' + (((n) / 100000)%10)), \ + ('0' + (((n) / 10000)%10)), \ + ('0' + (((n) / 1000)%10)), \ + ('0' + (((n) / 100)%10)), \ + ('0' + (((n) / 10)%10)), \ + ('0' + ((n) % 10)) + +/* Convert integer to hex digit literals. */ +#define HEX(n) \ + ('0' + ((n)>>28 & 0xF)), \ + ('0' + ((n)>>24 & 0xF)), \ + ('0' + ((n)>>20 & 0xF)), \ + ('0' + ((n)>>16 & 0xF)), \ + ('0' + ((n)>>12 & 0xF)), \ + ('0' + ((n)>>8 & 0xF)), \ + ('0' + ((n)>>4 & 0xF)), \ + ('0' + ((n) & 0xF)) + +/* Construct a string literal encoding the version number components. */ +#ifdef COMPILER_VERSION_MAJOR +char const info_version[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','[', + COMPILER_VERSION_MAJOR, +# ifdef COMPILER_VERSION_MINOR + '.', COMPILER_VERSION_MINOR, +# ifdef COMPILER_VERSION_PATCH + '.', COMPILER_VERSION_PATCH, +# ifdef COMPILER_VERSION_TWEAK + '.', COMPILER_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct a string literal encoding the internal version number. */ +#ifdef COMPILER_VERSION_INTERNAL +char const info_version_internal[] = { + 'I', 'N', 'F', 'O', ':', + 'c','o','m','p','i','l','e','r','_','v','e','r','s','i','o','n','_', + 'i','n','t','e','r','n','a','l','[', + COMPILER_VERSION_INTERNAL,']','\0'}; +#endif + +/* Construct a string literal encoding the version number components. */ +#ifdef SIMULATE_VERSION_MAJOR +char const info_simulate_version[] = { + 'I', 'N', 'F', 'O', ':', + 's','i','m','u','l','a','t','e','_','v','e','r','s','i','o','n','[', + SIMULATE_VERSION_MAJOR, +# ifdef SIMULATE_VERSION_MINOR + '.', SIMULATE_VERSION_MINOR, +# ifdef SIMULATE_VERSION_PATCH + '.', SIMULATE_VERSION_PATCH, +# ifdef SIMULATE_VERSION_TWEAK + '.', SIMULATE_VERSION_TWEAK, +# endif +# endif +# endif + ']','\0'}; +#endif + +/* Construct the string literal in pieces to prevent the source from + getting matched. Store it in a pointer rather than an array + because some compilers will just produce instructions to fill the + array rather than assigning a pointer to a static array. */ +char const* info_platform = "INFO" ":" "platform[" PLATFORM_ID "]"; +char const* info_arch = "INFO" ":" "arch[" ARCHITECTURE_ID "]"; + + + + +#if defined(__INTEL_COMPILER) && defined(_MSVC_LANG) && _MSVC_LANG < 201403L +# if defined(__INTEL_CXX11_MODE__) +# if defined(__cpp_aggregate_nsdmi) +# define CXX_STD 201402L +# else +# define CXX_STD 201103L +# endif +# else +# define CXX_STD 199711L +# endif +#elif defined(_MSC_VER) && defined(_MSVC_LANG) +# define CXX_STD _MSVC_LANG +#else +# define CXX_STD __cplusplus +#endif + +const char* info_language_dialect_default = "INFO" ":" "dialect_default[" +#if CXX_STD > 201703L + "20" +#elif CXX_STD >= 201703L + "17" +#elif CXX_STD >= 201402L + "14" +#elif CXX_STD >= 201103L + "11" +#else + "98" +#endif +"]"; + +/*--------------------------------------------------------------------------*/ + +int main(int argc, char* argv[]) +{ + int require = 0; + require += info_compiler[argc]; + require += info_platform[argc]; +#ifdef COMPILER_VERSION_MAJOR + require += info_version[argc]; +#endif +#ifdef COMPILER_VERSION_INTERNAL + require += info_version_internal[argc]; +#endif +#ifdef SIMULATE_ID + require += info_simulate[argc]; +#endif +#ifdef SIMULATE_VERSION_MAJOR + require += info_simulate_version[argc]; +#endif +#if defined(__CRAYXE) || defined(__CRAYXC) + require += info_cray[argc]; +#endif + require += info_language_dialect_default[argc]; + (void)argv; + return require; +} diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CompilerIdCXX/CMakeCXXCompilerId.o b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/3.18.4/CompilerIdCXX/CMakeCXXCompilerId.o new file mode 100644 index 0000000000000000000000000000000000000000..7d0c5a3b99e5a1ba91feaf98d70bfad88de7e926 GIT binary patch literal 1384 zcma)6KWGzS6#vrJG+=ErIJ96OgM(AerBJjkrp?JIRg0upJi^CEa!C#@mvFgg5CkV7 zR3W3II5{~xxj3|&j*c#F5jqBu>hImX&-_8r2k(CG|M$MU_vPdFZ>NhwB<2M^;05rT zIefBU&>Hv>>3^XCC4r7PM(e04h?C?5Nf|o5FqUJzWFC~px|RYKs2=rlfDa))PYE(|*J<#at=XP^CBbioOly^@qw6{>N7l*K}+FxHP*%rXv8k4pA*e{9!){#t%# zeBs&tPB`!y<2w|K?x_pRAk}NORV9>N|B>rgrQ9t}hU9n-SvHQizn3V=uBj_a=`>_5 zP)#RJnC)+mldf~URn(#TYC0=KL(7DD@G3Y?TOw0LbST+hAwSxMGjSsF#a@XaQ+~ZHB2U{>VXYN3?V<`WFt)0o(y&>sy2^7f(5h2Y zT`#n+UMUNq_x3q84SF4ec+03^>U8S)_;Phuix?fRPPCuL5Ij7&djTr1p=2l!MV*s%N z8Op^@WN0UV$uwh%5fIr4aa{5;a2bjEz1)Ysg2JCE0F(ujuHPqJg!C^!A`49Vr$`fG xn{*1&BwfGOk~FxksylLKC?a<2G2?IS!LE^yQusF)vZ-93 search starts here: + /Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/include + /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include + /Library/Developer/CommandLineTools/usr/include + /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/System/Library/Frameworks (framework directory) +End of search list. +Linking C executable cmTC_14aed +/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/bin/cmake -E cmake_link_script CMakeFiles/cmTC_14aed.dir/link.txt --verbose=1 +/Library/Developer/CommandLineTools/usr/bin/cc -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk -Wl,-search_paths_first -Wl,-headerpad_max_install_names -v -Wl,-v CMakeFiles/cmTC_14aed.dir/CMakeCCompilerABI.c.o -o cmTC_14aed +Apple clang version 13.1.6 (clang-1316.0.21.2.3) +Target: x86_64-apple-darwin21.4.0 +Thread model: posix +InstalledDir: /Library/Developer/CommandLineTools/usr/bin + "/Library/Developer/CommandLineTools/usr/bin/ld" -demangle -lto_library /Library/Developer/CommandLineTools/usr/lib/libLTO.dylib -dynamic -arch x86_64 -platform_version macos 12.0.0 12.3 -syslibroot /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk -o cmTC_14aed -search_paths_first -headerpad_max_install_names -v CMakeFiles/cmTC_14aed.dir/CMakeCCompilerABI.c.o -lSystem /Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/lib/darwin/libclang_rt.osx.a +@(#)PROGRAM:ld PROJECT:ld64-762 +BUILD 12:49:00 Mar 30 2022 +configured to support archs: armv6 armv7 armv7s arm64 arm64e arm64_32 i386 x86_64 x86_64h armv6m armv7k armv7m armv7em +Library search paths: + /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/lib +Framework search paths: + /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/System/Library/Frameworks/ + + + +Parsed C implicit include dir info from above output: rv=done + found start of include info + found start of implicit include info + add: [/Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/include] + add: [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include] + add: [/Library/Developer/CommandLineTools/usr/include] + end of search list found + collapse include dir [/Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/include] ==> [/Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/include] + collapse include dir [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include] ==> [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include] + collapse include dir [/Library/Developer/CommandLineTools/usr/include] ==> [/Library/Developer/CommandLineTools/usr/include] + implicit include dirs: [/Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/include;/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include;/Library/Developer/CommandLineTools/usr/include] + + +Parsed C implicit link information from above output: + link line regex: [^( *|.*[/\])(ld|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\]+-)?ld|collect2)[^/\]*( |$)] + ignore line: [Change Dir: /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles/CMakeTmp] + ignore line: [] + ignore line: [Run Build Command(s):/usr/bin/make cmTC_14aed/fast && /Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/cmTC_14aed.dir/build.make CMakeFiles/cmTC_14aed.dir/build] + ignore line: [Building C object CMakeFiles/cmTC_14aed.dir/CMakeCCompilerABI.c.o] + ignore line: [/Library/Developer/CommandLineTools/usr/bin/cc -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk -v -Wl -v -o CMakeFiles/cmTC_14aed.dir/CMakeCCompilerABI.c.o -c /Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeCCompilerABI.c] + ignore line: [Apple clang version 13.1.6 (clang-1316.0.21.2.3)] + ignore line: [Target: x86_64-apple-darwin21.4.0] + ignore line: [Thread model: posix] + ignore line: [InstalledDir: /Library/Developer/CommandLineTools/usr/bin] + ignore line: [clang: warning: -Wl -v: 'linker' input unused [-Wunused-command-line-argument]] + ignore line: [ "/Library/Developer/CommandLineTools/usr/bin/clang" -cc1 -triple x86_64-apple-macosx12.0.0 -Wundef-prefix=TARGET_OS_ -Wdeprecated-objc-isa-usage -Werror=deprecated-objc-isa-usage -Werror=implicit-function-declaration -emit-obj -mrelax-all --mrelax-relocations -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CMakeCCompilerABI.c -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fno-strict-return -fno-rounding-math -munwind-tables -target-sdk-version=12.3 -fvisibility-inlines-hidden-static-local-var -target-cpu penryn -tune-cpu generic -debugger-tuning=lldb -target-linker-version 762 -v -resource-dir /Library/Developer/CommandLineTools/usr/lib/clang/13.1.6 -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk -internal-isystem /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/local/include -internal-isystem /Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/include -internal-externc-isystem /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include -internal-externc-isystem /Library/Developer/CommandLineTools/usr/include -Wno-reorder-init-list -Wno-implicit-int-float-conversion -Wno-c99-designator -Wno-final-dtor-non-final-class -Wno-extra-semi-stmt -Wno-misleading-indentation -Wno-quoted-include-in-framework-header -Wno-implicit-fallthrough -Wno-enum-enum-conversion -Wno-enum-float-conversion -Wno-elaborated-enum-base -Wno-reserved-identifier -Wno-gnu-folding-constant -Wno-objc-load-method -fdebug-compilation-dir=/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles/CMakeTmp -ferror-limit 19 -stack-protector 1 -fstack-check -mdarwin-stkchk-strong-link -fblocks -fencode-extended-block-signature -fregister-global-dtors-with-atexit -fgnuc-version=4.2.1 -fmax-type-align=16 -fcommon -clang-vendor-feature=+messageToSelfInClassMethodIdReturnType -clang-vendor-feature=+disableInferNewAvailabilityFromInit -clang-vendor-feature=+disableNonDependentMemberExprInCurrentInstantiation -fno-odr-hash-protocols -clang-vendor-feature=+enableAggressiveVLAFolding -clang-vendor-feature=+revert09abecef7bbf -clang-vendor-feature=+thisNoAlignAttr -clang-vendor-feature=+thisNoNullAttr -mllvm -disable-aligned-alloc-awareness=1 -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o CMakeFiles/cmTC_14aed.dir/CMakeCCompilerABI.c.o -x c /Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeCCompilerABI.c] + ignore line: [clang -cc1 version 13.1.6 (clang-1316.0.21.2.3) default target x86_64-apple-darwin21.4.0] + ignore line: [ignoring nonexistent directory "/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/local/include"] + ignore line: [ignoring nonexistent directory "/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/Library/Frameworks"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/include] + ignore line: [ /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include] + ignore line: [ /Library/Developer/CommandLineTools/usr/include] + ignore line: [ /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/System/Library/Frameworks (framework directory)] + ignore line: [End of search list.] + ignore line: [Linking C executable cmTC_14aed] + ignore line: [/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/bin/cmake -E cmake_link_script CMakeFiles/cmTC_14aed.dir/link.txt --verbose=1] + ignore line: [/Library/Developer/CommandLineTools/usr/bin/cc -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk -Wl -search_paths_first -Wl -headerpad_max_install_names -v -Wl -v CMakeFiles/cmTC_14aed.dir/CMakeCCompilerABI.c.o -o cmTC_14aed ] + ignore line: [Apple clang version 13.1.6 (clang-1316.0.21.2.3)] + ignore line: [Target: x86_64-apple-darwin21.4.0] + ignore line: [Thread model: posix] + ignore line: [InstalledDir: /Library/Developer/CommandLineTools/usr/bin] + link line: [ "/Library/Developer/CommandLineTools/usr/bin/ld" -demangle -lto_library /Library/Developer/CommandLineTools/usr/lib/libLTO.dylib -dynamic -arch x86_64 -platform_version macos 12.0.0 12.3 -syslibroot /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk -o cmTC_14aed -search_paths_first -headerpad_max_install_names -v CMakeFiles/cmTC_14aed.dir/CMakeCCompilerABI.c.o -lSystem /Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/lib/darwin/libclang_rt.osx.a] + arg [/Library/Developer/CommandLineTools/usr/bin/ld] ==> ignore + arg [-demangle] ==> ignore + arg [-lto_library] ==> ignore, skip following value + arg [/Library/Developer/CommandLineTools/usr/lib/libLTO.dylib] ==> skip value of -lto_library + arg [-dynamic] ==> ignore + arg [-arch] ==> ignore + arg [x86_64] ==> ignore + arg [-platform_version] ==> ignore + arg [macos] ==> ignore + arg [12.0.0] ==> ignore + arg [12.3] ==> ignore + arg [-syslibroot] ==> ignore + arg [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk] ==> ignore + arg [-o] ==> ignore + arg [cmTC_14aed] ==> ignore + arg [-search_paths_first] ==> ignore + arg [-headerpad_max_install_names] ==> ignore + arg [-v] ==> ignore + arg [CMakeFiles/cmTC_14aed.dir/CMakeCCompilerABI.c.o] ==> ignore + arg [-lSystem] ==> lib [System] + arg [/Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/lib/darwin/libclang_rt.osx.a] ==> lib [/Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/lib/darwin/libclang_rt.osx.a] + Library search paths: [;/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/lib] + Framework search paths: [;/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/System/Library/Frameworks/] + remove lib [System] + remove lib [/Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/lib/darwin/libclang_rt.osx.a] + collapse library dir [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/lib] ==> [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/lib] + collapse framework dir [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/System/Library/Frameworks/] ==> [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/System/Library/Frameworks] + implicit libs: [] + implicit dirs: [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/lib] + implicit fwks: [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/System/Library/Frameworks] + + +Detecting CXX compiler ABI info compiled with the following output: +Change Dir: /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles/CMakeTmp + +Run Build Command(s):/usr/bin/make cmTC_821c0/fast && /Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/cmTC_821c0.dir/build.make CMakeFiles/cmTC_821c0.dir/build +Building CXX object CMakeFiles/cmTC_821c0.dir/CMakeCXXCompilerABI.cpp.o +/Library/Developer/CommandLineTools/usr/bin/c++ -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk -v -Wl,-v -o CMakeFiles/cmTC_821c0.dir/CMakeCXXCompilerABI.cpp.o -c /Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeCXXCompilerABI.cpp +Apple clang version 13.1.6 (clang-1316.0.21.2.3) +Target: x86_64-apple-darwin21.4.0 +Thread model: posix +InstalledDir: /Library/Developer/CommandLineTools/usr/bin +clang: warning: -Wl,-v: 'linker' input unused [-Wunused-command-line-argument] + "/Library/Developer/CommandLineTools/usr/bin/clang" -cc1 -triple x86_64-apple-macosx12.0.0 -Wundef-prefix=TARGET_OS_ -Wdeprecated-objc-isa-usage -Werror=deprecated-objc-isa-usage -Werror=implicit-function-declaration -emit-obj -mrelax-all --mrelax-relocations -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CMakeCXXCompilerABI.cpp -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fno-strict-return -fno-rounding-math -munwind-tables -target-sdk-version=12.3 -fvisibility-inlines-hidden-static-local-var -target-cpu penryn -tune-cpu generic -debugger-tuning=lldb -target-linker-version 762 -v -resource-dir /Library/Developer/CommandLineTools/usr/lib/clang/13.1.6 -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk -stdlib=libc++ -internal-isystem /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include/c++/v1 -internal-isystem /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/local/include -internal-isystem /Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/include -internal-externc-isystem /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include -internal-externc-isystem /Library/Developer/CommandLineTools/usr/include -Wno-reorder-init-list -Wno-implicit-int-float-conversion -Wno-c99-designator -Wno-final-dtor-non-final-class -Wno-extra-semi-stmt -Wno-misleading-indentation -Wno-quoted-include-in-framework-header -Wno-implicit-fallthrough -Wno-enum-enum-conversion -Wno-enum-float-conversion -Wno-elaborated-enum-base -Wno-reserved-identifier -Wno-gnu-folding-constant -Wno-objc-load-method -fdeprecated-macro -fdebug-compilation-dir=/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles/CMakeTmp -ferror-limit 19 -stack-protector 1 -fstack-check -mdarwin-stkchk-strong-link -fblocks -fencode-extended-block-signature -fregister-global-dtors-with-atexit -fgnuc-version=4.2.1 -fno-cxx-modules -fcxx-exceptions -fexceptions -fmax-type-align=16 -fcommon -clang-vendor-feature=+messageToSelfInClassMethodIdReturnType -clang-vendor-feature=+disableInferNewAvailabilityFromInit -clang-vendor-feature=+disableNonDependentMemberExprInCurrentInstantiation -fno-odr-hash-protocols -clang-vendor-feature=+enableAggressiveVLAFolding -clang-vendor-feature=+revert09abecef7bbf -clang-vendor-feature=+thisNoAlignAttr -clang-vendor-feature=+thisNoNullAttr -mllvm -disable-aligned-alloc-awareness=1 -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o CMakeFiles/cmTC_821c0.dir/CMakeCXXCompilerABI.cpp.o -x c++ /Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeCXXCompilerABI.cpp +clang -cc1 version 13.1.6 (clang-1316.0.21.2.3) default target x86_64-apple-darwin21.4.0 +ignoring nonexistent directory "/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/local/include" +ignoring nonexistent directory "/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/Library/Frameworks" +#include "..." search starts here: +#include <...> search starts here: + /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include/c++/v1 + /Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/include + /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include + /Library/Developer/CommandLineTools/usr/include + /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/System/Library/Frameworks (framework directory) +End of search list. +Linking CXX executable cmTC_821c0 +/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/bin/cmake -E cmake_link_script CMakeFiles/cmTC_821c0.dir/link.txt --verbose=1 +/Library/Developer/CommandLineTools/usr/bin/c++ -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk -Wl,-search_paths_first -Wl,-headerpad_max_install_names -v -Wl,-v CMakeFiles/cmTC_821c0.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_821c0 +Apple clang version 13.1.6 (clang-1316.0.21.2.3) +Target: x86_64-apple-darwin21.4.0 +Thread model: posix +InstalledDir: /Library/Developer/CommandLineTools/usr/bin + "/Library/Developer/CommandLineTools/usr/bin/ld" -demangle -lto_library /Library/Developer/CommandLineTools/usr/lib/libLTO.dylib -dynamic -arch x86_64 -platform_version macos 12.0.0 12.3 -syslibroot /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk -o cmTC_821c0 -search_paths_first -headerpad_max_install_names -v CMakeFiles/cmTC_821c0.dir/CMakeCXXCompilerABI.cpp.o -lc++ -lSystem /Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/lib/darwin/libclang_rt.osx.a +@(#)PROGRAM:ld PROJECT:ld64-762 +BUILD 12:49:00 Mar 30 2022 +configured to support archs: armv6 armv7 armv7s arm64 arm64e arm64_32 i386 x86_64 x86_64h armv6m armv7k armv7m armv7em +Library search paths: + /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/lib +Framework search paths: + /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/System/Library/Frameworks/ + + + +Parsed CXX implicit include dir info from above output: rv=done + found start of include info + found start of implicit include info + add: [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include/c++/v1] + add: [/Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/include] + add: [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include] + add: [/Library/Developer/CommandLineTools/usr/include] + end of search list found + collapse include dir [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include/c++/v1] ==> [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include/c++/v1] + collapse include dir [/Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/include] ==> [/Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/include] + collapse include dir [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include] ==> [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include] + collapse include dir [/Library/Developer/CommandLineTools/usr/include] ==> [/Library/Developer/CommandLineTools/usr/include] + implicit include dirs: [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include/c++/v1;/Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/include;/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include;/Library/Developer/CommandLineTools/usr/include] + + +Parsed CXX implicit link information from above output: + link line regex: [^( *|.*[/\])(ld|CMAKE_LINK_STARTFILE-NOTFOUND|([^/\]+-)?ld|collect2)[^/\]*( |$)] + ignore line: [Change Dir: /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles/CMakeTmp] + ignore line: [] + ignore line: [Run Build Command(s):/usr/bin/make cmTC_821c0/fast && /Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/cmTC_821c0.dir/build.make CMakeFiles/cmTC_821c0.dir/build] + ignore line: [Building CXX object CMakeFiles/cmTC_821c0.dir/CMakeCXXCompilerABI.cpp.o] + ignore line: [/Library/Developer/CommandLineTools/usr/bin/c++ -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk -v -Wl -v -o CMakeFiles/cmTC_821c0.dir/CMakeCXXCompilerABI.cpp.o -c /Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeCXXCompilerABI.cpp] + ignore line: [Apple clang version 13.1.6 (clang-1316.0.21.2.3)] + ignore line: [Target: x86_64-apple-darwin21.4.0] + ignore line: [Thread model: posix] + ignore line: [InstalledDir: /Library/Developer/CommandLineTools/usr/bin] + ignore line: [clang: warning: -Wl -v: 'linker' input unused [-Wunused-command-line-argument]] + ignore line: [ "/Library/Developer/CommandLineTools/usr/bin/clang" -cc1 -triple x86_64-apple-macosx12.0.0 -Wundef-prefix=TARGET_OS_ -Wdeprecated-objc-isa-usage -Werror=deprecated-objc-isa-usage -Werror=implicit-function-declaration -emit-obj -mrelax-all --mrelax-relocations -disable-free -disable-llvm-verifier -discard-value-names -main-file-name CMakeCXXCompilerABI.cpp -mrelocation-model pic -pic-level 2 -mframe-pointer=all -fno-strict-return -fno-rounding-math -munwind-tables -target-sdk-version=12.3 -fvisibility-inlines-hidden-static-local-var -target-cpu penryn -tune-cpu generic -debugger-tuning=lldb -target-linker-version 762 -v -resource-dir /Library/Developer/CommandLineTools/usr/lib/clang/13.1.6 -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk -stdlib=libc++ -internal-isystem /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include/c++/v1 -internal-isystem /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/local/include -internal-isystem /Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/include -internal-externc-isystem /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include -internal-externc-isystem /Library/Developer/CommandLineTools/usr/include -Wno-reorder-init-list -Wno-implicit-int-float-conversion -Wno-c99-designator -Wno-final-dtor-non-final-class -Wno-extra-semi-stmt -Wno-misleading-indentation -Wno-quoted-include-in-framework-header -Wno-implicit-fallthrough -Wno-enum-enum-conversion -Wno-enum-float-conversion -Wno-elaborated-enum-base -Wno-reserved-identifier -Wno-gnu-folding-constant -Wno-objc-load-method -fdeprecated-macro -fdebug-compilation-dir=/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles/CMakeTmp -ferror-limit 19 -stack-protector 1 -fstack-check -mdarwin-stkchk-strong-link -fblocks -fencode-extended-block-signature -fregister-global-dtors-with-atexit -fgnuc-version=4.2.1 -fno-cxx-modules -fcxx-exceptions -fexceptions -fmax-type-align=16 -fcommon -clang-vendor-feature=+messageToSelfInClassMethodIdReturnType -clang-vendor-feature=+disableInferNewAvailabilityFromInit -clang-vendor-feature=+disableNonDependentMemberExprInCurrentInstantiation -fno-odr-hash-protocols -clang-vendor-feature=+enableAggressiveVLAFolding -clang-vendor-feature=+revert09abecef7bbf -clang-vendor-feature=+thisNoAlignAttr -clang-vendor-feature=+thisNoNullAttr -mllvm -disable-aligned-alloc-awareness=1 -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o CMakeFiles/cmTC_821c0.dir/CMakeCXXCompilerABI.cpp.o -x c++ /Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeCXXCompilerABI.cpp] + ignore line: [clang -cc1 version 13.1.6 (clang-1316.0.21.2.3) default target x86_64-apple-darwin21.4.0] + ignore line: [ignoring nonexistent directory "/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/local/include"] + ignore line: [ignoring nonexistent directory "/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/Library/Frameworks"] + ignore line: [#include "..." search starts here:] + ignore line: [#include <...> search starts here:] + ignore line: [ /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include/c++/v1] + ignore line: [ /Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/include] + ignore line: [ /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/include] + ignore line: [ /Library/Developer/CommandLineTools/usr/include] + ignore line: [ /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/System/Library/Frameworks (framework directory)] + ignore line: [End of search list.] + ignore line: [Linking CXX executable cmTC_821c0] + ignore line: [/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/bin/cmake -E cmake_link_script CMakeFiles/cmTC_821c0.dir/link.txt --verbose=1] + ignore line: [/Library/Developer/CommandLineTools/usr/bin/c++ -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk -Wl -search_paths_first -Wl -headerpad_max_install_names -v -Wl -v CMakeFiles/cmTC_821c0.dir/CMakeCXXCompilerABI.cpp.o -o cmTC_821c0 ] + ignore line: [Apple clang version 13.1.6 (clang-1316.0.21.2.3)] + ignore line: [Target: x86_64-apple-darwin21.4.0] + ignore line: [Thread model: posix] + ignore line: [InstalledDir: /Library/Developer/CommandLineTools/usr/bin] + link line: [ "/Library/Developer/CommandLineTools/usr/bin/ld" -demangle -lto_library /Library/Developer/CommandLineTools/usr/lib/libLTO.dylib -dynamic -arch x86_64 -platform_version macos 12.0.0 12.3 -syslibroot /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk -o cmTC_821c0 -search_paths_first -headerpad_max_install_names -v CMakeFiles/cmTC_821c0.dir/CMakeCXXCompilerABI.cpp.o -lc++ -lSystem /Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/lib/darwin/libclang_rt.osx.a] + arg [/Library/Developer/CommandLineTools/usr/bin/ld] ==> ignore + arg [-demangle] ==> ignore + arg [-lto_library] ==> ignore, skip following value + arg [/Library/Developer/CommandLineTools/usr/lib/libLTO.dylib] ==> skip value of -lto_library + arg [-dynamic] ==> ignore + arg [-arch] ==> ignore + arg [x86_64] ==> ignore + arg [-platform_version] ==> ignore + arg [macos] ==> ignore + arg [12.0.0] ==> ignore + arg [12.3] ==> ignore + arg [-syslibroot] ==> ignore + arg [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk] ==> ignore + arg [-o] ==> ignore + arg [cmTC_821c0] ==> ignore + arg [-search_paths_first] ==> ignore + arg [-headerpad_max_install_names] ==> ignore + arg [-v] ==> ignore + arg [CMakeFiles/cmTC_821c0.dir/CMakeCXXCompilerABI.cpp.o] ==> ignore + arg [-lc++] ==> lib [c++] + arg [-lSystem] ==> lib [System] + arg [/Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/lib/darwin/libclang_rt.osx.a] ==> lib [/Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/lib/darwin/libclang_rt.osx.a] + Library search paths: [;/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/lib] + Framework search paths: [;/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/System/Library/Frameworks/] + remove lib [System] + remove lib [/Library/Developer/CommandLineTools/usr/lib/clang/13.1.6/lib/darwin/libclang_rt.osx.a] + collapse library dir [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/lib] ==> [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/lib] + collapse framework dir [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/System/Library/Frameworks/] ==> [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/System/Library/Frameworks] + implicit libs: [c++] + implicit dirs: [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/usr/lib] + implicit fwks: [/Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk/System/Library/Frameworks] + + +Performing C++ SOURCE FILE Test HAS_FLTO succeeded with the following output: +Change Dir: /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles/CMakeTmp + +Run Build Command(s):/usr/bin/make cmTC_3d8ad/fast && /Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/cmTC_3d8ad.dir/build.make CMakeFiles/cmTC_3d8ad.dir/build +Building CXX object CMakeFiles/cmTC_3d8ad.dir/src.cxx.o +/Library/Developer/CommandLineTools/usr/bin/c++ -DHAS_FLTO -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk -flto -o CMakeFiles/cmTC_3d8ad.dir/src.cxx.o -c /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles/CMakeTmp/src.cxx +Linking CXX executable cmTC_3d8ad +/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/bin/cmake -E cmake_link_script CMakeFiles/cmTC_3d8ad.dir/link.txt --verbose=1 +/Library/Developer/CommandLineTools/usr/bin/c++ -DHAS_FLTO -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk -Wl,-search_paths_first -Wl,-headerpad_max_install_names CMakeFiles/cmTC_3d8ad.dir/src.cxx.o -o cmTC_3d8ad -flto + + +Source file was: +int main() { return 0; } +Performing C++ SOURCE FILE Test HAS_FLTO_THIN succeeded with the following output: +Change Dir: /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles/CMakeTmp + +Run Build Command(s):/usr/bin/make cmTC_14bc1/fast && /Library/Developer/CommandLineTools/usr/bin/make -f CMakeFiles/cmTC_14bc1.dir/build.make CMakeFiles/cmTC_14bc1.dir/build +Building CXX object CMakeFiles/cmTC_14bc1.dir/src.cxx.o +/Library/Developer/CommandLineTools/usr/bin/c++ -DHAS_FLTO_THIN -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk -flto=thin -o CMakeFiles/cmTC_14bc1.dir/src.cxx.o -c /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles/CMakeTmp/src.cxx +Linking CXX executable cmTC_14bc1 +/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/bin/cmake -E cmake_link_script CMakeFiles/cmTC_14bc1.dir/link.txt --verbose=1 +/Library/Developer/CommandLineTools/usr/bin/c++ -DHAS_FLTO_THIN -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk -Wl,-search_paths_first -Wl,-headerpad_max_install_names CMakeFiles/cmTC_14bc1.dir/src.cxx.o -o cmTC_14bc1 -flto=thin + + +Source file was: +int main() { return 0; } diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/Makefile.cmake b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/Makefile.cmake new file mode 100644 index 000000000..93b160618 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/Makefile.cmake @@ -0,0 +1,138 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.18 + +# The generator used is: +set(CMAKE_DEPENDS_GENERATOR "Unix Makefiles") + +# The top level Makefile was generated from the following files: +set(CMAKE_MAKEFILE_DEPENDS + "CMakeCache.txt" + "../CMakeLists.txt" + "CMakeFiles/3.18.4/CMakeCCompiler.cmake" + "CMakeFiles/3.18.4/CMakeCXXCompiler.cmake" + "CMakeFiles/3.18.4/CMakeSystem.cmake" + "../pybind11/CMakeLists.txt" + "../pybind11/tools/JoinPaths.cmake" + "../pybind11/tools/pybind11Common.cmake" + "../pybind11/tools/pybind11NewTools.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeCCompiler.cmake.in" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeCCompilerABI.c" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeCInformation.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeCXXCompiler.cmake.in" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeCXXCompilerABI.cpp" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeCXXInformation.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeCheckCompilerFlagCommonPatterns.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeCommonLanguageInclude.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeCompilerIdDetection.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeDependentOption.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeDetermineCCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeDetermineCXXCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeDetermineCompileFeatures.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeDetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeDetermineCompilerABI.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeDetermineCompilerId.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeDetermineSystem.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeFindBinUtils.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeGenericSystem.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeInitializeConfigs.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeLanguageInformation.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakePackageConfigHelpers.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeParseImplicitIncludeInfo.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeParseImplicitLinkInfo.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeSystem.cmake.in" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeSystemSpecificInformation.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeSystemSpecificInitialize.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeTestCCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeTestCXXCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeTestCompilerCommon.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CMakeUnixFindMake.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CheckCXXCompilerFlag.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/CheckCXXSourceCompiles.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/ADSP-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/ARMCC-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/ARMClang-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/AppleClang-C.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/AppleClang-CXX.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/AppleClang-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/Borland-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/Bruce-C-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/CMakeCommonCompilerMacros.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/Clang-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/Clang-DetermineCompilerInternal.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/Clang.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/Comeau-CXX-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/Compaq-C-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/Compaq-CXX-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/Cray-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/Embarcadero-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/Fujitsu-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/GHS-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/GNU-C-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/GNU-CXX-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/GNU.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/HP-C-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/HP-CXX-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/IAR-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/IBMCPP-C-DetermineVersionInternal.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/IBMCPP-CXX-DetermineVersionInternal.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/Intel-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/MSVC-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/NVIDIA-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/OpenWatcom-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/PGI-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/PathScale-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/SCO-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/SDCC-C-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/SunPro-C-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/SunPro-CXX-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/TI-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/TinyCC-C-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/VisualAge-C-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/VisualAge-CXX-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/Watcom-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/XL-C-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/XL-CXX-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/XLClang-C-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/XLClang-CXX-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/zOS-C-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Compiler/zOS-CXX-DetermineCompiler.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/FindPackageHandleStandardArgs.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/FindPackageMessage.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/FindPython/Support.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/FindPython3.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/GNUInstallDirs.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Internal/CMakeCheckCompilerFlag.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Internal/FeatureTesting.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Platform/Apple-AppleClang-C.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Platform/Apple-AppleClang-CXX.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Platform/Apple-Clang-C.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Platform/Apple-Clang-CXX.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Platform/Apple-Clang.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Platform/Darwin-Determine-CXX.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Platform/Darwin-Initialize.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Platform/Darwin.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/Platform/UnixPaths.cmake" + "/Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/share/cmake-3.18/Modules/WriteBasicConfigVersionFile.cmake" + ) + +# The corresponding makefile is: +set(CMAKE_MAKEFILE_OUTPUTS + "Makefile" + "CMakeFiles/cmake.check_cache" + ) + +# Byproducts of CMake generate step: +set(CMAKE_MAKEFILE_PRODUCTS + "CMakeFiles/3.18.4/CMakeSystem.cmake" + "CMakeFiles/3.18.4/CMakeCCompiler.cmake" + "CMakeFiles/3.18.4/CMakeCXXCompiler.cmake" + "CMakeFiles/3.18.4/CMakeCCompiler.cmake" + "CMakeFiles/3.18.4/CMakeCXXCompiler.cmake" + "CMakeFiles/CMakeDirectoryInformation.cmake" + "pybind11/CMakeFiles/CMakeDirectoryInformation.cmake" + ) + +# Dependency information for all targets: +set(CMAKE_DEPEND_INFO_FILES + "CMakeFiles/mcts_alphazero.dir/DependInfo.cmake" + ) diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/Makefile2 b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/Makefile2 new file mode 100644 index 000000000..135b58717 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/Makefile2 @@ -0,0 +1,145 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.18 + +# Default target executed when no arguments are given to make. +default_target: all + +.PHONY : default_target + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Disable VCS-based implicit rules. +% : %,v + + +# Disable VCS-based implicit rules. +% : RCS/% + + +# Disable VCS-based implicit rules. +% : RCS/%,v + + +# Disable VCS-based implicit rules. +% : SCCS/s.% + + +# Disable VCS-based implicit rules. +% : s.% + + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Command-line flag to silence nested $(MAKE). +$(VERBOSE)MAKESILENT = -s + +#Suppress display of executed commands. +$(VERBOSE).SILENT: + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/bin/cmake + +# The command to remove a file. +RM = /Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/bin/cmake -E rm -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build + +#============================================================================= +# Directory level rules for the build root directory + +# The main recursive "all" target. +all: CMakeFiles/mcts_alphazero.dir/all +all: pybind11/all + +.PHONY : all + +# The main recursive "preinstall" target. +preinstall: pybind11/preinstall + +.PHONY : preinstall + +# The main recursive "clean" target. +clean: CMakeFiles/mcts_alphazero.dir/clean +clean: pybind11/clean + +.PHONY : clean + +#============================================================================= +# Directory level rules for directory pybind11 + +# Recursive "all" directory target. +pybind11/all: + +.PHONY : pybind11/all + +# Recursive "preinstall" directory target. +pybind11/preinstall: + +.PHONY : pybind11/preinstall + +# Recursive "clean" directory target. +pybind11/clean: + +.PHONY : pybind11/clean + +#============================================================================= +# Target rules for target CMakeFiles/mcts_alphazero.dir + +# All Build rule for target. +CMakeFiles/mcts_alphazero.dir/all: + $(MAKE) $(MAKESILENT) -f CMakeFiles/mcts_alphazero.dir/build.make CMakeFiles/mcts_alphazero.dir/depend + $(MAKE) $(MAKESILENT) -f CMakeFiles/mcts_alphazero.dir/build.make CMakeFiles/mcts_alphazero.dir/build + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --progress-dir=/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles --progress-num=1,2,3 "Built target mcts_alphazero" +.PHONY : CMakeFiles/mcts_alphazero.dir/all + +# Build rule for subdir invocation for target. +CMakeFiles/mcts_alphazero.dir/rule: cmake_check_build_system + $(CMAKE_COMMAND) -E cmake_progress_start /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles 3 + $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/mcts_alphazero.dir/all + $(CMAKE_COMMAND) -E cmake_progress_start /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles 0 +.PHONY : CMakeFiles/mcts_alphazero.dir/rule + +# Convenience name for target. +mcts_alphazero: CMakeFiles/mcts_alphazero.dir/rule + +.PHONY : mcts_alphazero + +# clean rule for target. +CMakeFiles/mcts_alphazero.dir/clean: + $(MAKE) $(MAKESILENT) -f CMakeFiles/mcts_alphazero.dir/build.make CMakeFiles/mcts_alphazero.dir/clean +.PHONY : CMakeFiles/mcts_alphazero.dir/clean + +#============================================================================= +# Special targets to cleanup operation of make. + +# Special rule to run CMake to check the build system integrity. +# No rule that depends on this can have commands that come from listfiles +# because they might be regenerated. +cmake_check_build_system: + $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0 +.PHONY : cmake_check_build_system + diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/TargetDirectories.txt b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/TargetDirectories.txt new file mode 100644 index 000000000..b7c37c2a7 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/TargetDirectories.txt @@ -0,0 +1,5 @@ +/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles/rebuild_cache.dir +/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles/edit_cache.dir +/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir +/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/pybind11/CMakeFiles/rebuild_cache.dir +/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/pybind11/CMakeFiles/edit_cache.dir diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/cmake.check_cache b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/cmake.check_cache new file mode 100644 index 000000000..3dccd7317 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/cmake.check_cache @@ -0,0 +1 @@ +# This file is generated by cmake for dependency checking of the CMakeCache.txt file diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/CXX.includecache b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/CXX.includecache new file mode 100644 index 000000000..d97822f66 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/CXX.includecache @@ -0,0 +1,718 @@ +#IncludeRegexLine: ^[ ]*[#%][ ]*(include|import)[ ]*[<"]([^">]+)([">]) + +#IncludeRegexScan: ^.*$ + +#IncludeRegexComplain: ^$ + +#IncludeRegexTransform: + +../pybind11/include/pybind11/attr.h +detail/common.h +../pybind11/include/pybind11/detail/common.h +cast.h +../pybind11/include/pybind11/cast.h +functional +- + +../pybind11/include/pybind11/buffer_info.h +detail/common.h +../pybind11/include/pybind11/detail/common.h + +../pybind11/include/pybind11/cast.h +detail/common.h +../pybind11/include/pybind11/detail/common.h +detail/descr.h +../pybind11/include/pybind11/detail/descr.h +detail/type_caster_base.h +../pybind11/include/pybind11/detail/type_caster_base.h +detail/typeid.h +../pybind11/include/pybind11/detail/typeid.h +pytypes.h +../pybind11/include/pybind11/pytypes.h +array +- +cstring +- +functional +- +iosfwd +- +iterator +- +memory +- +string +- +tuple +- +type_traits +- +utility +- +vector +- + +../pybind11/include/pybind11/detail/class.h +../attr.h +../pybind11/include/pybind11/attr.h +../options.h +../pybind11/include/pybind11/options.h + +../pybind11/include/pybind11/detail/common.h +yvals.h +- +crtdefs.h +- +Python.h +- +frameobject.h +- +pythread.h +- +cstddef +- +cstring +- +exception +- +forward_list +- +memory +- +stdexcept +- +string +- +type_traits +- +typeindex +- +unordered_map +- +unordered_set +- +vector +- +version +- + +../pybind11/include/pybind11/detail/descr.h +common.h +../pybind11/include/pybind11/detail/common.h + +../pybind11/include/pybind11/detail/init.h +class.h +../pybind11/include/pybind11/detail/class.h + +../pybind11/include/pybind11/detail/internals.h +common.h +../pybind11/include/pybind11/detail/common.h +../gil.h +../pybind11/include/pybind11/gil.h +../pytypes.h +../pybind11/include/pybind11/pytypes.h +exception +- + +../pybind11/include/pybind11/detail/type_caster_base.h +../pytypes.h +../pybind11/include/pybind11/pytypes.h +common.h +../pybind11/include/pybind11/detail/common.h +descr.h +../pybind11/include/pybind11/detail/descr.h +internals.h +../pybind11/include/pybind11/detail/internals.h +typeid.h +../pybind11/include/pybind11/detail/typeid.h +cstdint +- +iterator +- +new +- +string +- +type_traits +- +typeindex +- +typeinfo +- +unordered_map +- +utility +- +vector +- + +../pybind11/include/pybind11/detail/typeid.h +cstdio +- +cstdlib +- +cxxabi.h +- +common.h +../pybind11/include/pybind11/detail/common.h + +../pybind11/include/pybind11/gil.h +detail/common.h +../pybind11/include/pybind11/detail/common.h +detail/internals.h +../pybind11/include/pybind11/detail/internals.h + +../pybind11/include/pybind11/options.h +detail/common.h +../pybind11/include/pybind11/detail/common.h + +../pybind11/include/pybind11/pybind11.h +detail/class.h +../pybind11/include/pybind11/detail/class.h +detail/init.h +../pybind11/include/pybind11/detail/init.h +attr.h +../pybind11/include/pybind11/attr.h +gil.h +../pybind11/include/pybind11/gil.h +options.h +../pybind11/include/pybind11/options.h +cstdlib +- +cstring +- +memory +- +new +- +string +- +utility +- +vector +- +cxxabi.h +- + +../pybind11/include/pybind11/pytypes.h +detail/common.h +../pybind11/include/pybind11/detail/common.h +buffer_info.h +../pybind11/include/pybind11/buffer_info.h +assert.h +- +cstddef +- +exception +- +frameobject.h +- +iterator +- +memory +- +string +- +type_traits +- +typeinfo +- +utility +- +optional +- +string_view +- + +../pybind11/include/pybind11/stl.h +pybind11.h +../pybind11/include/pybind11/pybind11.h +detail/common.h +../pybind11/include/pybind11/detail/common.h +deque +- +list +- +map +- +ostream +- +set +- +unordered_map +- +unordered_set +- +valarray +- +optional +- +experimental/optional +- +variant +- + +/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/mcts_alphazero.cpp +node_alphazero.h +/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/node_alphazero.h +cmath +- +map +- +random +- +vector +- +pybind11/pybind11.h +- +pybind11/stl.h +- +functional +- +iostream +- + +/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/node_alphazero.cpp +node_alphazero.h +/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/node_alphazero.h +pybind11/pybind11.h +- +pybind11/stl.h +- + +/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/node_alphazero.h +map +- +string +- + +/Users/puyuan/opt/anaconda3/include/python3.8/Python.h +patchlevel.h +/Users/puyuan/opt/anaconda3/include/python3.8/patchlevel.h +pyconfig.h +/Users/puyuan/opt/anaconda3/include/python3.8/pyconfig.h +pymacconfig.h +/Users/puyuan/opt/anaconda3/include/python3.8/pymacconfig.h +limits.h +- +stdio.h +- +string.h +- +errno.h +- +stdlib.h +- +unistd.h +- +crypt.h +- +stddef.h +- +assert.h +- +pyport.h +/Users/puyuan/opt/anaconda3/include/python3.8/pyport.h +pymacro.h +/Users/puyuan/opt/anaconda3/include/python3.8/pymacro.h +pymath.h +/Users/puyuan/opt/anaconda3/include/python3.8/pymath.h +pytime.h +/Users/puyuan/opt/anaconda3/include/python3.8/pytime.h +pymem.h +/Users/puyuan/opt/anaconda3/include/python3.8/pymem.h +object.h +/Users/puyuan/opt/anaconda3/include/python3.8/object.h +objimpl.h +/Users/puyuan/opt/anaconda3/include/python3.8/objimpl.h +typeslots.h +/Users/puyuan/opt/anaconda3/include/python3.8/typeslots.h +pyhash.h +/Users/puyuan/opt/anaconda3/include/python3.8/pyhash.h +pydebug.h +/Users/puyuan/opt/anaconda3/include/python3.8/pydebug.h +bytearrayobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/bytearrayobject.h +bytesobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/bytesobject.h +unicodeobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/unicodeobject.h +longobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/longobject.h +longintrepr.h +/Users/puyuan/opt/anaconda3/include/python3.8/longintrepr.h +boolobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/boolobject.h +floatobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/floatobject.h +complexobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/complexobject.h +rangeobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/rangeobject.h +memoryobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/memoryobject.h +tupleobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/tupleobject.h +listobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/listobject.h +dictobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/dictobject.h +odictobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/odictobject.h +enumobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/enumobject.h +setobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/setobject.h +methodobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/methodobject.h +moduleobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/moduleobject.h +funcobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/funcobject.h +classobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/classobject.h +fileobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/fileobject.h +pycapsule.h +/Users/puyuan/opt/anaconda3/include/python3.8/pycapsule.h +traceback.h +/Users/puyuan/opt/anaconda3/include/python3.8/traceback.h +sliceobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/sliceobject.h +cellobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/cellobject.h +iterobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/iterobject.h +genobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/genobject.h +descrobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/descrobject.h +warnings.h +/Users/puyuan/opt/anaconda3/include/python3.8/warnings.h +weakrefobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/weakrefobject.h +structseq.h +/Users/puyuan/opt/anaconda3/include/python3.8/structseq.h +namespaceobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/namespaceobject.h +picklebufobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/picklebufobject.h +codecs.h +/Users/puyuan/opt/anaconda3/include/python3.8/codecs.h +pyerrors.h +/Users/puyuan/opt/anaconda3/include/python3.8/pyerrors.h +cpython/initconfig.h +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/initconfig.h +pystate.h +/Users/puyuan/opt/anaconda3/include/python3.8/pystate.h +context.h +/Users/puyuan/opt/anaconda3/include/python3.8/context.h +pyarena.h +/Users/puyuan/opt/anaconda3/include/python3.8/pyarena.h +modsupport.h +/Users/puyuan/opt/anaconda3/include/python3.8/modsupport.h +compile.h +/Users/puyuan/opt/anaconda3/include/python3.8/compile.h +pythonrun.h +/Users/puyuan/opt/anaconda3/include/python3.8/pythonrun.h +pylifecycle.h +/Users/puyuan/opt/anaconda3/include/python3.8/pylifecycle.h +ceval.h +/Users/puyuan/opt/anaconda3/include/python3.8/ceval.h +sysmodule.h +/Users/puyuan/opt/anaconda3/include/python3.8/sysmodule.h +osmodule.h +/Users/puyuan/opt/anaconda3/include/python3.8/osmodule.h +intrcheck.h +/Users/puyuan/opt/anaconda3/include/python3.8/intrcheck.h +import.h +/Users/puyuan/opt/anaconda3/include/python3.8/import.h +abstract.h +/Users/puyuan/opt/anaconda3/include/python3.8/abstract.h +bltinmodule.h +/Users/puyuan/opt/anaconda3/include/python3.8/bltinmodule.h +eval.h +/Users/puyuan/opt/anaconda3/include/python3.8/eval.h +pyctype.h +/Users/puyuan/opt/anaconda3/include/python3.8/pyctype.h +pystrtod.h +/Users/puyuan/opt/anaconda3/include/python3.8/pystrtod.h +pystrcmp.h +/Users/puyuan/opt/anaconda3/include/python3.8/pystrcmp.h +dtoa.h +/Users/puyuan/opt/anaconda3/include/python3.8/dtoa.h +fileutils.h +/Users/puyuan/opt/anaconda3/include/python3.8/fileutils.h +pyfpe.h +/Users/puyuan/opt/anaconda3/include/python3.8/pyfpe.h +tracemalloc.h +/Users/puyuan/opt/anaconda3/include/python3.8/tracemalloc.h + +/Users/puyuan/opt/anaconda3/include/python3.8/abstract.h +cpython/abstract.h +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/abstract.h + +/Users/puyuan/opt/anaconda3/include/python3.8/bltinmodule.h + +/Users/puyuan/opt/anaconda3/include/python3.8/boolobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/bytearrayobject.h +stdarg.h +- + +/Users/puyuan/opt/anaconda3/include/python3.8/bytesobject.h +stdarg.h +- + +/Users/puyuan/opt/anaconda3/include/python3.8/cellobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/ceval.h + +/Users/puyuan/opt/anaconda3/include/python3.8/classobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/code.h + +/Users/puyuan/opt/anaconda3/include/python3.8/codecs.h + +/Users/puyuan/opt/anaconda3/include/python3.8/compile.h +code.h +/Users/puyuan/opt/anaconda3/include/python3.8/code.h + +/Users/puyuan/opt/anaconda3/include/python3.8/complexobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/context.h + +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/abstract.h + +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/dictobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/fileobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/initconfig.h + +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/object.h + +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/objimpl.h + +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/pyerrors.h + +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/pylifecycle.h + +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/pymem.h + +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/pystate.h +cpython/initconfig.h +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/cpython/initconfig.h + +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/sysmodule.h + +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/traceback.h + +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/tupleobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/unicodeobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/descrobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/dictobject.h +cpython/dictobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/dictobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/dtoa.h + +/Users/puyuan/opt/anaconda3/include/python3.8/enumobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/eval.h + +/Users/puyuan/opt/anaconda3/include/python3.8/fileobject.h +cpython/fileobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/fileobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/fileutils.h + +/Users/puyuan/opt/anaconda3/include/python3.8/floatobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/frameobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/funcobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/genobject.h +pystate.h +/Users/puyuan/opt/anaconda3/include/python3.8/pystate.h + +/Users/puyuan/opt/anaconda3/include/python3.8/import.h + +/Users/puyuan/opt/anaconda3/include/python3.8/intrcheck.h + +/Users/puyuan/opt/anaconda3/include/python3.8/iterobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/listobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/longintrepr.h + +/Users/puyuan/opt/anaconda3/include/python3.8/longobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/memoryobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/methodobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/modsupport.h +stdarg.h +- + +/Users/puyuan/opt/anaconda3/include/python3.8/moduleobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/namespaceobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/object.h +pymem.h +/Users/puyuan/opt/anaconda3/include/python3.8/pymem.h +cpython/object.h +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/object.h + +/Users/puyuan/opt/anaconda3/include/python3.8/objimpl.h +pymem.h +/Users/puyuan/opt/anaconda3/include/python3.8/pymem.h +cpython/objimpl.h +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/objimpl.h + +/Users/puyuan/opt/anaconda3/include/python3.8/odictobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/osmodule.h + +/Users/puyuan/opt/anaconda3/include/python3.8/patchlevel.h + +/Users/puyuan/opt/anaconda3/include/python3.8/picklebufobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/pyarena.h + +/Users/puyuan/opt/anaconda3/include/python3.8/pycapsule.h + +/Users/puyuan/opt/anaconda3/include/python3.8/pyconfig.h + +/Users/puyuan/opt/anaconda3/include/python3.8/pyctype.h + +/Users/puyuan/opt/anaconda3/include/python3.8/pydebug.h + +/Users/puyuan/opt/anaconda3/include/python3.8/pyerrors.h +stdarg.h +- +cpython/pyerrors.h +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/pyerrors.h + +/Users/puyuan/opt/anaconda3/include/python3.8/pyfpe.h + +/Users/puyuan/opt/anaconda3/include/python3.8/pyhash.h + +/Users/puyuan/opt/anaconda3/include/python3.8/pylifecycle.h +cpython/pylifecycle.h +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/pylifecycle.h + +/Users/puyuan/opt/anaconda3/include/python3.8/pymacconfig.h + +/Users/puyuan/opt/anaconda3/include/python3.8/pymacro.h + +/Users/puyuan/opt/anaconda3/include/python3.8/pymath.h +pyconfig.h +/Users/puyuan/opt/anaconda3/include/python3.8/pyconfig.h + +/Users/puyuan/opt/anaconda3/include/python3.8/pymem.h +pyport.h +/Users/puyuan/opt/anaconda3/include/python3.8/pyport.h +cpython/pymem.h +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/pymem.h + +/Users/puyuan/opt/anaconda3/include/python3.8/pyport.h +pyconfig.h +/Users/puyuan/opt/anaconda3/include/python3.8/pyconfig.h +inttypes.h +- +stdlib.h +- +ieeefp.h +- +math.h +- +sys/time.h +- +time.h +- +sys/time.h +- +time.h +- +sys/select.h +- +sys/stat.h +- +stat.h +- +sys/types.h +- +sys/termio.h +- +ctype.h +- +wctype.h +- + +/Users/puyuan/opt/anaconda3/include/python3.8/pystate.h +pythread.h +/Users/puyuan/opt/anaconda3/include/python3.8/pythread.h +cpython/pystate.h +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/pystate.h + +/Users/puyuan/opt/anaconda3/include/python3.8/pystrcmp.h + +/Users/puyuan/opt/anaconda3/include/python3.8/pystrtod.h + +/Users/puyuan/opt/anaconda3/include/python3.8/pythonrun.h + +/Users/puyuan/opt/anaconda3/include/python3.8/pythread.h +pthread.h +- + +/Users/puyuan/opt/anaconda3/include/python3.8/pytime.h +pyconfig.h +/Users/puyuan/opt/anaconda3/include/python3.8/pyconfig.h +object.h +/Users/puyuan/opt/anaconda3/include/python3.8/object.h + +/Users/puyuan/opt/anaconda3/include/python3.8/rangeobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/setobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/sliceobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/structseq.h + +/Users/puyuan/opt/anaconda3/include/python3.8/sysmodule.h +cpython/sysmodule.h +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/sysmodule.h + +/Users/puyuan/opt/anaconda3/include/python3.8/traceback.h +cpython/traceback.h +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/traceback.h + +/Users/puyuan/opt/anaconda3/include/python3.8/tracemalloc.h + +/Users/puyuan/opt/anaconda3/include/python3.8/tupleobject.h +cpython/tupleobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/tupleobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/typeslots.h + +/Users/puyuan/opt/anaconda3/include/python3.8/unicodeobject.h +stdarg.h +- +ctype.h +- +wchar.h +- +cpython/unicodeobject.h +/Users/puyuan/opt/anaconda3/include/python3.8/cpython/unicodeobject.h + +/Users/puyuan/opt/anaconda3/include/python3.8/warnings.h + +/Users/puyuan/opt/anaconda3/include/python3.8/weakrefobject.h + diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/DependInfo.cmake b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/DependInfo.cmake new file mode 100644 index 000000000..3ec47bb93 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/DependInfo.cmake @@ -0,0 +1,28 @@ +# The set of languages for which implicit dependencies are needed: +set(CMAKE_DEPENDS_LANGUAGES + "CXX" + ) +# The set of files for implicit dependencies of each language: +set(CMAKE_DEPENDS_CHECK_CXX + "/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/mcts_alphazero.cpp" "/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o" + "/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/node_alphazero.cpp" "/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o" + ) +set(CMAKE_CXX_COMPILER_ID "AppleClang") + +# Preprocessor definitions for this target. +set(CMAKE_TARGET_DEFINITIONS_CXX + "mcts_alphazero_EXPORTS" + ) + +# The include file search paths: +set(CMAKE_CXX_TARGET_INCLUDE_PATH + "/Users/puyuan/opt/anaconda3/include/python3.8" + "../pybind11/include" + ) + +# Targets to which this target links. +set(CMAKE_TARGET_LINKED_INFO_FILES + ) + +# Fortran module output directory. +set(CMAKE_Fortran_TARGET_MODULE_DIR "") diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/build.make b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/build.make new file mode 100644 index 000000000..4763afd07 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/build.make @@ -0,0 +1,133 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.18 + +# Delete rule output on recipe failure. +.DELETE_ON_ERROR: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Disable VCS-based implicit rules. +% : %,v + + +# Disable VCS-based implicit rules. +% : RCS/% + + +# Disable VCS-based implicit rules. +% : RCS/%,v + + +# Disable VCS-based implicit rules. +% : SCCS/s.% + + +# Disable VCS-based implicit rules. +% : s.% + + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Command-line flag to silence nested $(MAKE). +$(VERBOSE)MAKESILENT = -s + +#Suppress display of executed commands. +$(VERBOSE).SILENT: + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/bin/cmake + +# The command to remove a file. +RM = /Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/bin/cmake -E rm -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build + +# Include any dependencies generated for this target. +include CMakeFiles/mcts_alphazero.dir/depend.make + +# Include the progress variables for this target. +include CMakeFiles/mcts_alphazero.dir/progress.make + +# Include the compile flags for this target's objects. +include CMakeFiles/mcts_alphazero.dir/flags.make + +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: CMakeFiles/mcts_alphazero.dir/flags.make +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: ../mcts_alphazero.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_1) "Building CXX object CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o" + /Library/Developer/CommandLineTools/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o -c /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/mcts_alphazero.cpp + +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.i" + /Library/Developer/CommandLineTools/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/mcts_alphazero.cpp > CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.i + +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.s" + /Library/Developer/CommandLineTools/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/mcts_alphazero.cpp -o CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.s + +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: CMakeFiles/mcts_alphazero.dir/flags.make +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: ../node_alphazero.cpp + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --progress-dir=/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_2) "Building CXX object CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o" + /Library/Developer/CommandLineTools/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -o CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o -c /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/node_alphazero.cpp + +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.i: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Preprocessing CXX source to CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.i" + /Library/Developer/CommandLineTools/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -E /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/node_alphazero.cpp > CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.i + +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green "Compiling CXX source to assembly CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.s" + /Library/Developer/CommandLineTools/usr/bin/c++ $(CXX_DEFINES) $(CXX_INCLUDES) $(CXX_FLAGS) -S /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/node_alphazero.cpp -o CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.s + +# Object files for target mcts_alphazero +mcts_alphazero_OBJECTS = \ +"CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o" \ +"CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o" + +# External object files for target mcts_alphazero +mcts_alphazero_EXTERNAL_OBJECTS = + +mcts_alphazero.cpython-38-darwin.so: CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o +mcts_alphazero.cpython-38-darwin.so: CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o +mcts_alphazero.cpython-38-darwin.so: CMakeFiles/mcts_alphazero.dir/build.make +mcts_alphazero.cpython-38-darwin.so: CMakeFiles/mcts_alphazero.dir/link.txt + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --green --bold --progress-dir=/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Linking CXX shared module mcts_alphazero.cpython-38-darwin.so" + $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/mcts_alphazero.dir/link.txt --verbose=$(VERBOSE) + /Library/Developer/CommandLineTools/usr/bin/strip -x /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/mcts_alphazero.cpython-38-darwin.so + +# Rule to build all files generated by this target. +CMakeFiles/mcts_alphazero.dir/build: mcts_alphazero.cpython-38-darwin.so + +.PHONY : CMakeFiles/mcts_alphazero.dir/build + +CMakeFiles/mcts_alphazero.dir/clean: + $(CMAKE_COMMAND) -P CMakeFiles/mcts_alphazero.dir/cmake_clean.cmake +.PHONY : CMakeFiles/mcts_alphazero.dir/clean + +CMakeFiles/mcts_alphazero.dir/depend: + cd /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build && $(CMAKE_COMMAND) -E cmake_depends "Unix Makefiles" /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/DependInfo.cmake --color=$(COLOR) +.PHONY : CMakeFiles/mcts_alphazero.dir/depend + diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/cmake_clean.cmake b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/cmake_clean.cmake new file mode 100644 index 000000000..785c7b652 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/cmake_clean.cmake @@ -0,0 +1,11 @@ +file(REMOVE_RECURSE + "CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o" + "CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o" + "mcts_alphazero.cpython-38-darwin.so" + "mcts_alphazero.pdb" +) + +# Per-language clean rules from dependency scanning. +foreach(lang CXX) + include(CMakeFiles/mcts_alphazero.dir/cmake_clean_${lang}.cmake OPTIONAL) +endforeach() diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/depend.internal b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/depend.internal new file mode 100644 index 000000000..bf9d9da99 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/depend.internal @@ -0,0 +1,215 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.18 + +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o + ../pybind11/include/pybind11/attr.h + ../pybind11/include/pybind11/buffer_info.h + ../pybind11/include/pybind11/cast.h + ../pybind11/include/pybind11/detail/class.h + ../pybind11/include/pybind11/detail/common.h + ../pybind11/include/pybind11/detail/descr.h + ../pybind11/include/pybind11/detail/init.h + ../pybind11/include/pybind11/detail/internals.h + ../pybind11/include/pybind11/detail/type_caster_base.h + ../pybind11/include/pybind11/detail/typeid.h + ../pybind11/include/pybind11/gil.h + ../pybind11/include/pybind11/options.h + ../pybind11/include/pybind11/pybind11.h + ../pybind11/include/pybind11/pytypes.h + ../pybind11/include/pybind11/stl.h + /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/mcts_alphazero.cpp + /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/node_alphazero.h + /Users/puyuan/opt/anaconda3/include/python3.8/Python.h + /Users/puyuan/opt/anaconda3/include/python3.8/abstract.h + /Users/puyuan/opt/anaconda3/include/python3.8/bltinmodule.h + /Users/puyuan/opt/anaconda3/include/python3.8/boolobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/bytearrayobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/bytesobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/cellobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/ceval.h + /Users/puyuan/opt/anaconda3/include/python3.8/classobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/code.h + /Users/puyuan/opt/anaconda3/include/python3.8/codecs.h + /Users/puyuan/opt/anaconda3/include/python3.8/compile.h + /Users/puyuan/opt/anaconda3/include/python3.8/complexobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/context.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/abstract.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/dictobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/fileobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/initconfig.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/object.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/objimpl.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/pyerrors.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/pylifecycle.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/pymem.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/pystate.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/sysmodule.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/traceback.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/tupleobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/unicodeobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/descrobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/dictobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/dtoa.h + /Users/puyuan/opt/anaconda3/include/python3.8/enumobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/eval.h + /Users/puyuan/opt/anaconda3/include/python3.8/fileobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/fileutils.h + /Users/puyuan/opt/anaconda3/include/python3.8/floatobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/frameobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/funcobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/genobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/import.h + /Users/puyuan/opt/anaconda3/include/python3.8/intrcheck.h + /Users/puyuan/opt/anaconda3/include/python3.8/iterobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/listobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/longintrepr.h + /Users/puyuan/opt/anaconda3/include/python3.8/longobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/memoryobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/methodobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/modsupport.h + /Users/puyuan/opt/anaconda3/include/python3.8/moduleobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/namespaceobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/object.h + /Users/puyuan/opt/anaconda3/include/python3.8/objimpl.h + /Users/puyuan/opt/anaconda3/include/python3.8/odictobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/osmodule.h + /Users/puyuan/opt/anaconda3/include/python3.8/patchlevel.h + /Users/puyuan/opt/anaconda3/include/python3.8/picklebufobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/pyarena.h + /Users/puyuan/opt/anaconda3/include/python3.8/pycapsule.h + /Users/puyuan/opt/anaconda3/include/python3.8/pyconfig.h + /Users/puyuan/opt/anaconda3/include/python3.8/pyctype.h + /Users/puyuan/opt/anaconda3/include/python3.8/pydebug.h + /Users/puyuan/opt/anaconda3/include/python3.8/pyerrors.h + /Users/puyuan/opt/anaconda3/include/python3.8/pyfpe.h + /Users/puyuan/opt/anaconda3/include/python3.8/pyhash.h + /Users/puyuan/opt/anaconda3/include/python3.8/pylifecycle.h + /Users/puyuan/opt/anaconda3/include/python3.8/pymacconfig.h + /Users/puyuan/opt/anaconda3/include/python3.8/pymacro.h + /Users/puyuan/opt/anaconda3/include/python3.8/pymath.h + /Users/puyuan/opt/anaconda3/include/python3.8/pymem.h + /Users/puyuan/opt/anaconda3/include/python3.8/pyport.h + /Users/puyuan/opt/anaconda3/include/python3.8/pystate.h + /Users/puyuan/opt/anaconda3/include/python3.8/pystrcmp.h + /Users/puyuan/opt/anaconda3/include/python3.8/pystrtod.h + /Users/puyuan/opt/anaconda3/include/python3.8/pythonrun.h + /Users/puyuan/opt/anaconda3/include/python3.8/pythread.h + /Users/puyuan/opt/anaconda3/include/python3.8/pytime.h + /Users/puyuan/opt/anaconda3/include/python3.8/rangeobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/setobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/sliceobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/structseq.h + /Users/puyuan/opt/anaconda3/include/python3.8/sysmodule.h + /Users/puyuan/opt/anaconda3/include/python3.8/traceback.h + /Users/puyuan/opt/anaconda3/include/python3.8/tracemalloc.h + /Users/puyuan/opt/anaconda3/include/python3.8/tupleobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/typeslots.h + /Users/puyuan/opt/anaconda3/include/python3.8/unicodeobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/warnings.h + /Users/puyuan/opt/anaconda3/include/python3.8/weakrefobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o + ../pybind11/include/pybind11/attr.h + ../pybind11/include/pybind11/buffer_info.h + ../pybind11/include/pybind11/cast.h + ../pybind11/include/pybind11/detail/class.h + ../pybind11/include/pybind11/detail/common.h + ../pybind11/include/pybind11/detail/descr.h + ../pybind11/include/pybind11/detail/init.h + ../pybind11/include/pybind11/detail/internals.h + ../pybind11/include/pybind11/detail/type_caster_base.h + ../pybind11/include/pybind11/detail/typeid.h + ../pybind11/include/pybind11/gil.h + ../pybind11/include/pybind11/options.h + ../pybind11/include/pybind11/pybind11.h + ../pybind11/include/pybind11/pytypes.h + ../pybind11/include/pybind11/stl.h + /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/node_alphazero.cpp + /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/node_alphazero.h + /Users/puyuan/opt/anaconda3/include/python3.8/Python.h + /Users/puyuan/opt/anaconda3/include/python3.8/abstract.h + /Users/puyuan/opt/anaconda3/include/python3.8/bltinmodule.h + /Users/puyuan/opt/anaconda3/include/python3.8/boolobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/bytearrayobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/bytesobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/cellobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/ceval.h + /Users/puyuan/opt/anaconda3/include/python3.8/classobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/code.h + /Users/puyuan/opt/anaconda3/include/python3.8/codecs.h + /Users/puyuan/opt/anaconda3/include/python3.8/compile.h + /Users/puyuan/opt/anaconda3/include/python3.8/complexobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/context.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/abstract.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/dictobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/fileobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/initconfig.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/object.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/objimpl.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/pyerrors.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/pylifecycle.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/pymem.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/pystate.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/sysmodule.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/traceback.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/tupleobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/cpython/unicodeobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/descrobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/dictobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/dtoa.h + /Users/puyuan/opt/anaconda3/include/python3.8/enumobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/eval.h + /Users/puyuan/opt/anaconda3/include/python3.8/fileobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/fileutils.h + /Users/puyuan/opt/anaconda3/include/python3.8/floatobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/frameobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/funcobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/genobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/import.h + /Users/puyuan/opt/anaconda3/include/python3.8/intrcheck.h + /Users/puyuan/opt/anaconda3/include/python3.8/iterobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/listobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/longintrepr.h + /Users/puyuan/opt/anaconda3/include/python3.8/longobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/memoryobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/methodobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/modsupport.h + /Users/puyuan/opt/anaconda3/include/python3.8/moduleobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/namespaceobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/object.h + /Users/puyuan/opt/anaconda3/include/python3.8/objimpl.h + /Users/puyuan/opt/anaconda3/include/python3.8/odictobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/osmodule.h + /Users/puyuan/opt/anaconda3/include/python3.8/patchlevel.h + /Users/puyuan/opt/anaconda3/include/python3.8/picklebufobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/pyarena.h + /Users/puyuan/opt/anaconda3/include/python3.8/pycapsule.h + /Users/puyuan/opt/anaconda3/include/python3.8/pyconfig.h + /Users/puyuan/opt/anaconda3/include/python3.8/pyctype.h + /Users/puyuan/opt/anaconda3/include/python3.8/pydebug.h + /Users/puyuan/opt/anaconda3/include/python3.8/pyerrors.h + /Users/puyuan/opt/anaconda3/include/python3.8/pyfpe.h + /Users/puyuan/opt/anaconda3/include/python3.8/pyhash.h + /Users/puyuan/opt/anaconda3/include/python3.8/pylifecycle.h + /Users/puyuan/opt/anaconda3/include/python3.8/pymacconfig.h + /Users/puyuan/opt/anaconda3/include/python3.8/pymacro.h + /Users/puyuan/opt/anaconda3/include/python3.8/pymath.h + /Users/puyuan/opt/anaconda3/include/python3.8/pymem.h + /Users/puyuan/opt/anaconda3/include/python3.8/pyport.h + /Users/puyuan/opt/anaconda3/include/python3.8/pystate.h + /Users/puyuan/opt/anaconda3/include/python3.8/pystrcmp.h + /Users/puyuan/opt/anaconda3/include/python3.8/pystrtod.h + /Users/puyuan/opt/anaconda3/include/python3.8/pythonrun.h + /Users/puyuan/opt/anaconda3/include/python3.8/pythread.h + /Users/puyuan/opt/anaconda3/include/python3.8/pytime.h + /Users/puyuan/opt/anaconda3/include/python3.8/rangeobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/setobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/sliceobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/structseq.h + /Users/puyuan/opt/anaconda3/include/python3.8/sysmodule.h + /Users/puyuan/opt/anaconda3/include/python3.8/traceback.h + /Users/puyuan/opt/anaconda3/include/python3.8/tracemalloc.h + /Users/puyuan/opt/anaconda3/include/python3.8/tupleobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/typeslots.h + /Users/puyuan/opt/anaconda3/include/python3.8/unicodeobject.h + /Users/puyuan/opt/anaconda3/include/python3.8/warnings.h + /Users/puyuan/opt/anaconda3/include/python3.8/weakrefobject.h diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/depend.make b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/depend.make new file mode 100644 index 000000000..fa3685a5a --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/depend.make @@ -0,0 +1,215 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.18 + +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: ../pybind11/include/pybind11/attr.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: ../pybind11/include/pybind11/buffer_info.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: ../pybind11/include/pybind11/cast.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: ../pybind11/include/pybind11/detail/class.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: ../pybind11/include/pybind11/detail/common.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: ../pybind11/include/pybind11/detail/descr.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: ../pybind11/include/pybind11/detail/init.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: ../pybind11/include/pybind11/detail/internals.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: ../pybind11/include/pybind11/detail/type_caster_base.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: ../pybind11/include/pybind11/detail/typeid.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: ../pybind11/include/pybind11/gil.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: ../pybind11/include/pybind11/options.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: ../pybind11/include/pybind11/pybind11.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: ../pybind11/include/pybind11/pytypes.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: ../pybind11/include/pybind11/stl.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: ../mcts_alphazero.cpp +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: ../node_alphazero.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/Python.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/abstract.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/bltinmodule.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/boolobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/bytearrayobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/bytesobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cellobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/ceval.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/classobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/code.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/codecs.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/compile.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/complexobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/context.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/abstract.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/dictobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/fileobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/initconfig.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/object.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/objimpl.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/pyerrors.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/pylifecycle.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/pymem.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/pystate.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/sysmodule.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/traceback.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/tupleobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/unicodeobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/descrobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/dictobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/dtoa.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/enumobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/eval.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/fileobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/fileutils.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/floatobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/frameobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/funcobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/genobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/import.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/intrcheck.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/iterobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/listobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/longintrepr.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/longobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/memoryobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/methodobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/modsupport.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/moduleobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/namespaceobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/object.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/objimpl.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/odictobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/osmodule.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/patchlevel.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/picklebufobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pyarena.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pycapsule.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pyconfig.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pyctype.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pydebug.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pyerrors.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pyfpe.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pyhash.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pylifecycle.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pymacconfig.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pymacro.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pymath.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pymem.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pyport.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pystate.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pystrcmp.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pystrtod.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pythonrun.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pythread.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pytime.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/rangeobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/setobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/sliceobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/structseq.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/sysmodule.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/traceback.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/tracemalloc.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/tupleobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/typeslots.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/unicodeobject.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/warnings.h +CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/weakrefobject.h + +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: ../pybind11/include/pybind11/attr.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: ../pybind11/include/pybind11/buffer_info.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: ../pybind11/include/pybind11/cast.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: ../pybind11/include/pybind11/detail/class.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: ../pybind11/include/pybind11/detail/common.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: ../pybind11/include/pybind11/detail/descr.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: ../pybind11/include/pybind11/detail/init.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: ../pybind11/include/pybind11/detail/internals.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: ../pybind11/include/pybind11/detail/type_caster_base.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: ../pybind11/include/pybind11/detail/typeid.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: ../pybind11/include/pybind11/gil.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: ../pybind11/include/pybind11/options.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: ../pybind11/include/pybind11/pybind11.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: ../pybind11/include/pybind11/pytypes.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: ../pybind11/include/pybind11/stl.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: ../node_alphazero.cpp +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: ../node_alphazero.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/Python.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/abstract.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/bltinmodule.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/boolobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/bytearrayobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/bytesobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cellobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/ceval.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/classobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/code.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/codecs.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/compile.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/complexobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/context.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/abstract.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/dictobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/fileobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/initconfig.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/object.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/objimpl.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/pyerrors.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/pylifecycle.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/pymem.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/pystate.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/sysmodule.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/traceback.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/tupleobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/cpython/unicodeobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/descrobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/dictobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/dtoa.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/enumobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/eval.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/fileobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/fileutils.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/floatobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/frameobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/funcobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/genobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/import.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/intrcheck.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/iterobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/listobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/longintrepr.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/longobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/memoryobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/methodobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/modsupport.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/moduleobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/namespaceobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/object.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/objimpl.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/odictobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/osmodule.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/patchlevel.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/picklebufobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pyarena.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pycapsule.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pyconfig.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pyctype.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pydebug.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pyerrors.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pyfpe.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pyhash.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pylifecycle.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pymacconfig.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pymacro.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pymath.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pymem.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pyport.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pystate.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pystrcmp.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pystrtod.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pythonrun.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pythread.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/pytime.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/rangeobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/setobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/sliceobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/structseq.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/sysmodule.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/traceback.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/tracemalloc.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/tupleobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/typeslots.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/unicodeobject.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/warnings.h +CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o: /Users/puyuan/opt/anaconda3/include/python3.8/weakrefobject.h + diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/flags.make b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/flags.make new file mode 100644 index 000000000..8d16b7c1e --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/flags.make @@ -0,0 +1,10 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.18 + +# compile CXX with /Library/Developer/CommandLineTools/usr/bin/c++ +CXX_DEFINES = -Dmcts_alphazero_EXPORTS + +CXX_INCLUDES = -isystem /Users/puyuan/opt/anaconda3/include/python3.8 -isystem /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/ctree_alphazero/pybind11/include + +CXX_FLAGS = -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk -fPIC -fvisibility=hidden -flto -std=gnu++11 + diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/link.txt b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/link.txt new file mode 100644 index 000000000..613950d0b --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/link.txt @@ -0,0 +1 @@ +/Library/Developer/CommandLineTools/usr/bin/c++ -isysroot /Library/Developer/CommandLineTools/SDKs/MacOSX12.3.sdk -bundle -Wl,-headerpad_max_install_names -Xlinker -undefined -Xlinker dynamic_lookup -flto -o mcts_alphazero.cpython-38-darwin.so CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/mcts_alphazero.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..ef1004ea997ce4e8cd42e7098130cf47a5e2f387 GIT binary patch literal 2448640 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

!pwK>M_ZTHP&7cj`&!_*4^gP?-> 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%0Dpk- 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

e#n#fjVr%#cjjd^X=LM2a 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

2B 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

lRkg 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 TLgI!?jp-|{|!k=G;KSN0d3`08r&`v!E8HaX< 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

2;v?DSW(D0VD$79(XV~I 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

*dzy@uDMcj~DOaa{s;;Z(-&68}H6`&gcBG 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

QCV#M>uFrvKzgi|>XHVEYK(-|~}qQ?{$7 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%0DZ?J;vbus(&t^f$^c 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 literal 0 HcmV?d00001 diff --git a/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o b/lzero/mcts/ctree/ctree_alphazero/build/CMakeFiles/mcts_alphazero.dir/node_alphazero.cpp.o new file mode 100644 index 0000000000000000000000000000000000000000..3411ca8c801dd9f5a06cf36094467eeffbaa19cb GIT binary patch literal 1973568 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⋙VQi(d}5SB4r)OdJefw zglF;7KFwtmF#TlujN!=gFry*qVte7D8B^_Z^QX?9SC~Iz!EhK!z7<;2)c(oqY~?H?`_XsGM& zW1`S+*b;EXTkZ<}vQ^ zfkGBTgbho~9Z2pdM@1NJbN9Ml;hSrZdw6e{{2rTMZ-P*bS!QjCfAf5Z_4ww{01KsE zJOdAk=hu?B&bOIw*m12`As*=dM4#HHYX{!2qn}vOvvclyy${VVaDSvZ_EtcdW6noq zTG6t_Ix#>W9&q?K@!|5mmAzi=YRXxg`%=RrMxFWCmQf$!*a+>@nMw6x$VaxvO5vj~ z*pj*9rmT>=KC>0wo+uEk+%d;_Wa->sav}#M*kD^LJU%FT%2A_(0A~k^^`huFq^IPQ zdgSd)cHXJJFuBx$TextG%~w&|XvuWV~Q-6YB8 zdFY2nXO~Xa-YMDYrJ3*Fk`*?y)AQbomuFNa)u=9Rwym|?w6s)fX$g(4shrcI(^Squ z*zbU7)J_9mY4PLVYgO`#OYuoMu19x!ij+DDo&cHua#_Shz(TKfi_`%lQ zEB56z-<|u9q1i&(pB}N+eRiO_+%j_-ODt=Nx%RPjF+p(t2$pDVkYH(WXwcYb6MTUO zU_sQH^E9KUh(_jq=I=5SLuUW%qBqyml_L56BzstVhs)!g87;4Hc^rkS)O)^brR?22 zDS0=sy@$j{PmZ`dz=P1zpYmgy8G`Tp(f z4H|;BypY+t)0CG-N=s`$J7pUv>*MoIm_v-Seyo02b;c}sjtPgb_JOeH`|2apjj1Or`h3897&S>F!I+Y3^99`~YU$UX#`8)>@H-cgzx{85#(uF^j4pa1cPe0pg4*+#Ewlm6jb zpU-oL+ScdqQ5<|(y@1=D>v}+rzbiRqzP`N#wq7c_I+P{vT3+nm%cLuUjR9SSIx$~6 zA@HjoEFDT~VRj!D;R<2o^?F9bP9iTNADMSMEnx(L|Jg+;&fc-UEN`$pN0R?O_acKA zrnK9E;sZ#jT^Ma#9ly@5OUN}+cijS&ihK?#auQTz^SG}heY1x2&872;X4Q6r!|D%@ zq5g&cd<-`47_P;9aGxpp(PX=h+^51K{Istd_4n1sB^0jwg6YM>Zqh$r_b;S{r*J-} zTWh8##H`=>U3h`f^3~Mj*`}V$7rs0!LCV+$9QHK!oi0wAiyou&PPp@mygZIalR?{RtxE@S`fqBoz#HJHb-m=r~p zyosbHQt8~bz21D5+QDJ3rx=lOO4mv;u#W0J{>OOf@Oq8KfCf^}@oho%N=|@DBWB+?Mm+jq*8cd%5oL zT}I;$t~-Qc{7iS?Yr_p&d2Q+hwl*O)Pz(}}Ylnorq^wPwYo#36i>&KT<=PSKx$Up3 zuRqT}f1%Aj<0~&HZ{9pL!#;ibjD-v5A<>oWt3mwZ)S`KX1=9;=EJW$?qN2hXQwxe` z%t2ZoZA~h_k4#sUU#f$`N{aXdN)bRM}?+PMZJ>~CjlTx*j2JS355cWn&PA!t`@!a-w+1yLa5BYgyTQd%S3JdXbd33mV zLf)XMQlY_(YMb&0o`2L^(s8)|Mya`gs{`DMWF%AkySWcf2h%4$lA}2mNs)PR7dA`N z=%u5LC9BV63^ZMno$89!aEbFah(^!!%REwcI`<260! zC?9WM)|r-UP09=TRJoj`K0;8@YZ<{3j`f&4^_|@uO2OdM+RTzcbb-<3E6F zBJ|^w_#O8>c=b}Ad&zJcI8189{AYao!tzx0r)6<$-6SVLxV{0sQzLa>CxCMO8{f(N zFmH%NBlY|i@+oi;j317;vOXu=GENYY$(d{vR*Mnn96Zo(-S?pblIC_G~js_ukS%@Chl zI@wTSoZVe;?b29syR%ceS9su(Fu<*5K8*Bn+s%O=N9~?nUz67ZVd9-}dncdI_yML_ zWI<)a%);boSaurRHXc~-+8J_Q>Gg3-Z>t8B*jrfJfKg>AC|nb%q*0S zTU8c3=RlcLW7!sB5C+FP3QU52Rl@j>ty`D%tu$yXrv9sch`ncuxzuyh=8`+Rzg%S# zOcP2qmT^XWVGaGlFc%L+(y43%f3&z_R(!}0A>;nF_``wv;_N|+E?@lNz>vi^;j^O4 zGw84CmrI8Q&vF+Qz4pqpFUL1^e>3KWXc+ccsIYnVWqb4E_?(Q%#%Ei7O)g%&^yawF zZgZ3l$sL^W=_faTV!E*Z^E|gU_m(+zrc6(^Mkf{oZvE@)cXZbtj*knPAe???PW0HV z#mP1yzuU}vEvCU;cE#o0+M=tE)()#QjPGH}an~1?uZbF6)miQa5&fR#(}1C-W%3*S zK0kViHF9RBHEO>@RwVa3WJNkPvg5P4N8rM)qwQ-wD5yDx6|1?u{IjTE#H(5&4MIFZ zi}5;9gG|{o&}epjS94gK90Hue>=(=eY^}N;H3z;0;gt~l;EFESMhaQmYJ|Oo*?o;Q zg=nX=&|sB$O|o}LmyzvH%}$x{FTBnaU)WemK8-Fv;faJ$D^Lf+-OFK#QKbUxvlAFX z%XhYS_n7dVsb^Yhv8C7H-iJ+id5AOLsEF1oOGFq+AhE4AqyV=qUqEP-k zqc7Qcbf4CZ&9B!HkQ*hlwQkkT4h|aNUaovDolO?4=1-8A_Y67zqSqhKewam+F zfXsm3IQrPBroE^l@s%&_oXgT)1`hVTz;ywxlX9O!gk2I0m|Sm+aRQQ08(+?TG2R&C zuBu5`)wA+r4hQjm_W2-9K-BUO6s^Wke^1Nu;fUG?d`EM3%KQ~|L2;AQZCu#j`y|5) zVtG(?JWqZ6t3GBNS8C8k`RJrv{&GKuEXP-IInL*Yud{SqSm%|gySDRp=I6G#m+VhJ zeeE{oTqU;R=aT^}V&Ra;?#}yv?i!TRWt4N>obqYR15h$Np)NE>Fi2(q-{*baMY1_S zlapj&9RDECK&!O~k-7a>YtlXmd#6l*J4E{+GU8WIiIw@=su=+ZEuO-R5i|28DH8U+ z!Ihs&=THia{H*1F@L9hv`%j-G&6PK=(_2ezm-Cx*TB5kC;2O)@wcS^xX8>Dw%|w7f8?r3#5b2Luosbnw_sE|84_tT7tNi{ zdYMeO7ZysD9RO7D%{!9ED&-wnlN00C5WaITXq?i{+SA+AHm`S#Ic$ti{l{Yj%;5kw zM3t`E@fgoN&{O|!wB!xZXi_d|EBMhg=aroqZiW7x7=MI5kLe#e{4L=pum2}ZNBG7( z^^)!|K(@&<<$weKJa?F^SKii{d1rW*njUq^{h@OV^t(1K|O|L-FenNE7u=?$-89PI=BgQU76gI&Xe>A%>sEGxQEGz#mMi%SQX?+{Q z4kclRH?Gh4kP@A8=eOoILs(PJP)*|N*Joh&cq#y4xkE=9g~l!!|1^|-+f8Fewi6CS znrdb<(BhlScnjtfY_0f5=VL(AotL-!c@13EQcTYtAjkAvS1B>QpqHWA#q$pfMD3vzrYXsP$8>Ps8?kK)(Ob3BT8kvpL+G^E7e+JrPo?C^ zs0l8;;V<6WE7#LLa#+fFNB<`oWlgfYvS2%wGc6Q4n`m_C2akY{cM>#C@w<53tiGm_ z3Y>1~{Kd@~TG*W2ZhU$!tq1+Hi&EY{_hAu_`o`+Hzf6kR!(Wz%_`ka}zeyZeuC4B^ zaxu2T#dr!e(8)Zc-ApdVyuZ3{Dd{w6gl-ycE$=b!`Mg_Ke6M~!kEzo6uu~Y1BM^c7 zvH*AKW>)hZ9tW-b2kn@I?RX5ehZmkVbM zSM{@&?Yv!4Qoa5zll1!yxqiQLhivbu?Lqfgs^iyoG9s>+5v@h&am6yBWp-3g-9`Wi zlz)!d_3SA6TWPqtpy>6dHe218wW*+;`k>pF*&f>rL!wjJXICG&Ij_vtEgvOI;T4}> z-E^~ijcha&cN*6TMi|TJ{c}|7g4|+tNHb3{9y%c`>8VtQB_HF_&e@7xVfovcHIA8` z9+2-nX>#knlk1Yq4ZQ_dtie39dx}p`QCcHk|3W{^HTPkYqeb>%Q#zgSDtrnm8`2`D$?8Vd3No%;`Uc#Hu z%iLTD>gxc?BCS0ri!^oFIfJqoK6MN_(4lR$YECxsIyq_gf!C3zvAfNU#!lx;qp^#zh)1dB^+1hLxO+pm zK=~i^PaR*5=J92c3|Oy7JwnCeiWMy7>V1=?>##Zt2Ye|$lx9kL1hT@KB?RFe~4jw%!2V7r=&NNy&=nz6#OY{ z$B$ZXzGw|c`)PqvzcdCTtj?QyR*AVo53BtlKBjQvckj(&Is4}8@(BdEJ$_T^EPktVmnm0| z{*mmZ^>2T^+W4U}SQ5`dRTj@eO7H1EHG>O-wpl%Xy%L{mlh-5V@qk9SG9`rWM|zB$ z5K|k{ITuFtDbh^O1f~u(BD)x$US>Z^=;q6r)**sDcO`4=wcNq;ehvfhox!MzPCOkW<$BOp(1S~8~tRl zn9ApO@HwfTW8+ElRF-Nab3u*KmD{n zO@G~&X*>1VU5DwOO3TbH`8xj1e}-rdo*8Qh{p*mrtF=#_jR`s+#LpGne-ZTYl}XWt zYY$k1^!8(pYOOX8?{60cfn+D&FTAu<&v@+x9P41eXoq&ZR5JqjmF*^pVVCgk5ihFw z&3Z0A?ib*op4rzyFCvmR%opxw_mM9{#&Maw-}?443uM1t6oe#pzPF|>f0e`|Y2n+s zJuhpsEzAyNt~4RE5#FNts0}3Lap};8zsI-a6`FEJkk6u7bil7+&(EQ9dy^Ii#N1wV zp!6?B+hh4Np(p5%#r}SqF^qTF_V_eP{_IgB3~U-(7dAHNZg*4 zvdA7G)idKX>aBE#RECk%!9J`R<3fB{09iIEqi|(?YJ2< zBatRj`|GoXiIaLB?sM2w9kS1T(k%hAHT5}c-aU4oY`U8^lvV^=U&z&+B`g`{N2t9% zY<@ren+c%-jTYG+ZCU+L7o1cYp4L}Bsifa`$>HZ7NRLg8n1P(bC$-h6;(QJZ>FV-K zm#m^uxP0{fvGV1fBhQ85^15kh1G3%O3HK(3Y7XQ_CYP)N{xu65*rE?sy|XN#<*EY5 zV#BO$3vxHl+Z^8#^RPC_oEk0k55=~X5c2oI^}F-*XbHXh`EX!Fk=Z_5qgm05YE7#G zbZ`i;ez5)4T^qkr?iMs=%V<7^3tu*Ut(AQP*1N*e`c2%a*Ut%XH0>p4d9=z|ZWmQC zEIC(8@}bsLau3AG!Ml|FvmC6GdjIssrR2N`xsE<9{70^{RY+9f>jQ%HUq$tZwI&d+cYoAxqJiBnr10$n>T#lNcL#UDvQ_ z-^2hu=vG7%EIENcM^##lTdY$8_2G8$Q2blVT=Ka!If3V+Dkp2FsjZCJ+{)MpD?_$L zBI3Tf?XH=ff|9lhrUjIdxJ_?+8Hs{}OGU50wG)|U?4Mnf`iVv8b1x%amoC$G&NiBt zDzopr0G}(1!>a4xczHJS+)Iw=M8k+*K-Sy8 zsX4mGKK2ou7Bc*qu>1O&8~RI4&1-YR?(7%cNIo&+_zOsNbM{yGXl6h2PW@hW(t0gV zTGxA%*8iQc`PJ6OF0rF;(1=IOj{cumI;lc8OkQw5JQ;}`{d)pC_?`>aSY;XIz&E6JX;N9Dh!sy-G!VB8$ZLS| zZ~XSQ>J7Sk+U{)~-LK=l?VA<(O$R#I+fFR3puMePR{MKf!`J4|JJ{R2bNyY%dt1|i z-1~E{d~eISN7;L@x0w#+8h+&KUwts%yZ)SBa_&{m$KIBQ^MB^&Hyu3rhC(lVZ_Bw) zeZKo3-`m0<0Z4zi82ufJe?#RT^vw+;W%1HFq+C0Bv0CekVB~RM5P2HBI;2eRlAob= za3a#$RG4`EGta$zv3h%+hn&NuJ5Mx_4L4c(v!WU7U4F1O;hL2k6L0*%1{o7CA#=qm z3MSqH)x5;xZ^b)%QnPK1=tht?LZ`SQnVc^+r2>c|9 zFz^P?`Xo`pz>8?g4VqATGzN!h^I)hysnu%>)4rDiN$-XN%+cL?L80V2N@IswUQS6!i7W(8 zXgHgC2ZlONnR#kvNtT?N$^FZPL__q?E((I$Uqb$DiOyW~wXhLCf7o9lQx!S)y!7K8 zKlw>iJjWKKZ{~%I@|;>$kncq1iM}+}7yZV1rMLu&jNq_$Qg~D~_HVcy!tiJ^6JvG} zffMds^YFmWqnyn3EzNO7?|a(Az03KlT82u39@sqU94i|C00o&w*USS;%UJ zdsle~2|5b?XvL^|ww%?_bg;Dz#&43%s=a||j_nO9+&iCVO8TuY?p-$pdpw@&X1?yJ zBVVh1=g`&K#k~t}BHX(n78UN@14|M2VYqkIhpOHPXdm}Z7Z>;bZ7SS5U2I&_Z3^z) z?D+UrS6GuFV5W_XYrVEbm@{cwubD_zc6l^_J;pEHu9Hv4tdmgjGA-T3$DgKL^JpUu z#J{%g@hXqi^cr%c4p>b{&Dux~{JV-P=T&uMFnW<}F1g*Evr<~a2(Fuqf0D;exM>Wn zo=R`Bhcn!}>|x+ihI@CcrTUXS{dSHO$RW@Dv@kIh zUzDE@kMTt{j{ETNMQfoiZxi+MvrG?oVaOw^Bs>+2yEUgxpLAFUE%UNsFK~Yvy@OW{ z#C zzq36E6fY*vefzPdPWYb5R%MlGKgXQQ`}y?D8ti4#{HtkQkL%I}1;Z{7AN}fS^=!Vj z8e6dcMUY=DnQ^vEy5{KyP@hp-f{xydFzPUEEF7y3xFJ7JHxQtgS>bT*zh*JKI_t1RmPsa!Yq`%J)emFkHiI`#>0)up*Zk(~58%}) zs(>#%oqxWR%_9k+uB;3=H_R*Up9I1=}I%= z#@@#9>5T7c-VE3{Bv6e{XI&rmOka*q=lat2wf686rD}XSaa`chD2`9JXTD=z3ELyR z_;jsX>I(hwy_SROrGIvjW1xGnA$)T*IN#<3OE?Prx9b5}Qt>K__F^YOXs9#qkeC~! z6K{$Z?#?nrnu+Q|0(#vCb;07_4`7fom-L<^zNnYU&a z0EI5piNiS-VPbMRL@S}t)vgcQ#tJ;MmS-ixQ7@VRYEVMyuM0D`zwE%sjeUbw;;Ish z5Jb;c$6CntlyqM`+aEpntdip$W^y)@d6UgLGF&d;p$ zBiK9@!CKoR*zGEUZT_qsf;|?+aOg;vQ`2eo9Dh1(ABWE0k8vp+I(|O)V)8sEIg8{n zaOi3)z0Y{shj*^Ux^g*pNuB6oz7anhy7qM3U4bF;Sg9zKTAK7 zmX%#9rc+F#hmqwSnAjl8wRag_Nt;GDUnf5R7hj+80RLzk4B7q^Xk zu-Q00dG#uJ>|^;JR{yqyMg->{%gckRovu%(iBTpU@e9g2XixW=z{V}%&PX=i9r#Al z6}{Nzt_=F_E&TY%|0{owOF_yBee_FH{}!r!vJpu;Y2h4Gj#Cz=2>1h8^x29WM16Yd z7?Zn61hti#sZ&EK&|$MpNK4X&V|%1J5YMK%dBMYRe12+AI*y%MgEBefaLWNp@y{>x z)qfzqrgb*tojF}}JS!Y9b(vBYvEwbuBCfEmB2b;D@?OZPp#no4=Au1JIj(Q|)3Dlu z39`+i)gfSl>aDt|!N{7ii-OR;T>9_ZHGo=6L)w?hPW97|)YYcs9SC)*YMFg=;jY6x z@LV{eAFjLm`Uw8}vX#99Donk6;r9-5d=yq?5yN9;U=n(ON#KQ`&_R7&TcNS^v*bUf z7py%^Mc)it9*?|8PtolWHQa04NN{kp zA$rGuG27b=BJ&=LyF%%F`7_k)&QG}o*Qbt1zV0T9Ovc@txJpCEF2DWm{#nEcIpn* zGw@-x6{Pb2h23zD;TK^RextT>P6m3DM1oIb!SlE>tRd! zR+MzZn9m@gs`>f4+k@?H!$bqa)jf@`#1~5ORVxBR4U|t%^KH>lZS;zgXjci%wO#bm zEw>jWw4F9}5e=w@m(o~;H_=LJ^~Ld(Ftd>T9gbBY7bNM**&FeU;}o@ z$5bAw*&cSMmyfT(J=^MOIb`+<_u@w_pD)XINJs~)gOPu~h8HAam8_H6n-XJ+m43>7 zOAp8S_-%U6Qpa&GB8XesA;^)uZca$2H*gjy$Aqa8t)s$`CfOK}OAV{FcobSIze!yHSm)tYxdmdaCF z&f5M~P7+XzVLcXI0?55gf)bh(qiu;S5XZ8j(J%824pS9^O{}cF`NP`hmL*p9S`}l; z(bnEl{&JN5RMXw1dlrR?!uKQU3dL!aT<&BUc=fAOiq{NRdb3FN` zkN8^6k85aet#+%|%JdOmEAp$7e7U0Wf|ZgI(y-|`k%* zsaz+G8V0qhpQI$&z54Y<<@#g(a(&Ac%k|Sfa$VZv)qA+)OW-sj;Z9vVrl-uEV!yeR z7@PA(RgA6VwXo|hKgQ6|XolHigSF5aDX4fRbN4Q@kT0iCOLvcvYa2a1Ua}94d8Eprao=~OENMnw znbu$_>s}@>s9Okd8Kq=HR5Wm9Y=kSbByQ=glQx9wN>Sk$a$-?SffWt0-9JLiI*y*) zvaDkA8gwO8otx`XovXPUT}pq#xkX2-wl1qf;_^pOONGA#J|4AEKX_&*psh*#EbT#R zy5+j3>|OVj)2CRUXA$|#=+j*atSV!zD0CAefPG`kEd#ishQJm3*$ohkeoq#4Ybb3G5u7@oki3@;2EZ z;;XCni-`jcKYZL&u>wsNw8rq zYNT0MT`L$u1gKb~Ba(AILE? zpUNmDW4@h(S>vcs+}KNW02--a9WZpvCqOKY+XFX5Z7w+Gn55NuW&j(htY&5-pq0$d z`;HjKNK*sA@y9v=Fv)KGWqkJ?k5$D4MGLP!)@j-?huf(Umupsp7%bRmCs6;2y&ppb zX{a)P~FkYifmh11Ri@vbpU|x-oYtV^vL!6r)VmEOQ z5{yAsV{AA5T_Zf0t!OrpO@@L;24YdOV1%Z_GF)$J!5kYjn!FgYFJp_YzoRs^CiDbR zK>+Mo3l8^36RkS{^n)kG9l7CC< z*9k5g(Z55O-5DuOBj+S9I}{#=SAWkY=(}i)Q;LGtYIF`Th`I%x}G_l+n zY57GkIX}d=xE_p{wG8}H6o5RaTmVMlnn`y(ag?4SyC~|%H_VA|@Cbz%aNouQXE0zM zi~b@R$(H2In`9T!6LQJ=U<&8uXe(E?-6=6U|+fR;0Y00fR5JV>~1)_Uq#^eBj;3>pI_bsC{R^4jMa$4 zczt6Wo4%UBUtd%XRY-@nU2PEFb7(*irPsF}{2fG8LfV>-gP>o(iu&tez1l@V*ai(H zLO(&JyAjVwzI?3!ebjY#D)Fv@MJBU{Yy@$jvv$~H&&3(*^11HR&4lykhU`=rtU7A@ zo$M>IfEdg&ix{ke7;Hb)6Veu;T~7?A>4aH+ZGA0cu=T`X4Ni?`1!u6yDh4b1C~L38 zV6|Yd6M}e-GgywqHARN$i325JS23itxgsRGrU8WeD3~Z&A74~xYK|!h>u#E5B6iG< z-F3q!GLyKwfvd8>e)ZiL`&j}PL=3`>7A%OU2TX~fR>+HG3O5|D!YMzW>agEmIUiuFD8BNx{QBf$GDVFZF!(S4b4 z&{zyY!%Z5%ZLiiu?gm|6HTKnsi+8;L!JhkV$6Jc;uke+I;hG@?~3Y4FX@h4*x`1}Ai#Nr*%+=Wx@ZK5w7g|nWn8lq@#yUtJpAT2u-tfHZLImgUCRa^Kjsv3gI!L`==$#U3G5DVG zSqVATAd%TJRaj4xN%#%-!l6F%vwG#=y<$Qf9ybJsOE_Sx?(x#eq+7QwQzjf_j0yLw zjTU<93<9ni&_6photcoRy20lRYj!$40M0#YXsA4kwBL<8;SL>NBQ$)PXTqq)=yli* zYa%k&WXtsU&*jY!GnIgtTPwzIh^7Y3=a;8d&d95T233+$V_YE*0%tu2aaK4D(&T;T zuj9KP*tp{T3P}W=(q=K>6XE!BHucA{Rvxb4Q(uJP6`dS0S9$*z+53akb+@T=uqAhuPcCPQu&H_Bh7js);K_{X+w^u>-~56Bwr) zvnBm`qZnWU`@|oj#j#-D#!VfgOSvT27)~DG`2(R0FGy~E&D4FP6?~2CmjcGJMcrS@ z86(g2zLm|}21vaB++IPvMnC_paEbMIpv~iZ_^PWb@L!t-t{9oIEQ0fdOX7+A?m7qP z(NjM7(TIQ$2N?Z}ie^yxvFs;~Ea$5r&4KX4O127LeEGzQ<$M){u8r^F`eT8^4$-aE z4A7tU=F z10;2E)jW|)3~(PY067SH@4Knu_s+ z(0*4`zvYfQSSEC35{mddlbv3zz3DH_t6~pPQX}m`mo9(v;whxa~u6c!rHH-#22FLGp#k zzo9L2BpXto*mFi6hlY0S+oHo+@vKdXX_dACpn4;M#GU#&%kXZd5>a{nHSGS9E!i1= zOMY4xr5y;<@T0cpkw#Jo@Z3=Zi#BG&vU<73Cb7@m`wP(4>F(*M7*q_FYg9QEQm&>-_rLW0WHW?j z5`ksLf@Wy{d9}h`_Sr-8Wf#4e);!lq^2d48xK0k<4qdN^3RRg`_*|@oc^c_jwQqrF z&YK_O%`=l~Sx~!z4pG6BEH_9$Jen{S(`FYw1*N8^ZXduuaum* z{*@wBxRWz3Z)<5mu*(Fj6RF2Mr|bH=)xOT61Gx|9O1Y*=N=D1Ktq0Y4FuuJ<$6@^H z+Fy0wKhobMI;&?fi~I3eO=lO+$!j;Y#4qPUo-ZZ8M9H#JD5XhyCF;jO$rfa{)udQ0 z!%M}9)JcNyFZPKhUMPD3Rn0cjVKH|}7;EG=T5050@!_4pfQv(uq14E~X0CtPf(8JZ z{-Mru73nD{JE^yZXmT9r9{K#8f~MwARGd96Z!=*)_dd}lyvP!w!@IYKp&|Qt6g^m- z^H2OB=QNVpFBIWNn!h&KBW)W9!Qqy-SRKFi_CO)plE5|I4vAc^IUMXTRW^2j6EPgm zkqjZjH%DjDD8xYsJOco5#E}q<&Q);3s$euAQK{YadJUzG_EOI zHsjB94N6;_Yb9GvzTEur$;|;Hzg9Q5xrX=5*^?xZ}pOV6E>g`?qFv{Is^(rV0}%#aN_Y23AyQYkYl zcWS0mX2RkkLq)ECFCW^qEI1l=3m~F&YvL|UM%S@Y7D3-LzjZX@#<1O3oxXqZHsm-tV)KIbg{c%%nHEtO-!JuDd6F)9_ zDqy-1*KAx@Lf0S*+Bh54Mo=^>4fEqnIj)kNz~7=0?ojIIf4I%#gXOgi17>}VHU_Dx z?9bn}duAu&jvyiaLCuPf%f<;ayKCbs(~M5s8S{CY%Xba8lD*U^B|1 zKoZ0LC|TK5Qz`d*{R)y%+);O(w?3Nh8Omz#ygsE@4FVoM_xo{06Ec%SRjp=pxd861 z)uchE>pA4iPD@CM)XRX>3Z_fQW0m#{(=qNJ=ryEqC$D!*@H;o+GTy7WW}qHz{Blrr z3UxuF!RHVl6z40wPnsphf-VmI6pYq$#@Mo`y*a5FtfaKM@qNm%9;|Z|e=QQG#C*Np zgJH1!E|ZN%(jQ{+w=9?bM8|jIM=jSc%NN}?;hKWeBUrA~jS7UAD*vWU&Xgo`+R-^! zrX`xJ@Ap_!u2QWFTHj~_0v&Q%Map}@3z3wfSsTy?0f!4VR$ zVmbEtmq%`nkB(Ud(c^Rqi2m9|L7)Vs2>o8gm#0X}_9AIY5DMrQl$jr>$*c9EZDgF- zNfEH&76GUjSy1)sLbF8Z%_XLM28K}sXh_|;*q^2Ymy>p!f=Rz=s>%PRpLre|~Zm+(Y>c-Ka7t8R+W- z+9l0Zr+e{g?4Moa*g(kl;eDNa>b_x^5#$b=C1^u3Y{#j|z*B!<349FEA5^_e^2cbQHMZhUjTJl~?)hNiz+nR1Qgh;}ep;D@hy1`+ob@(({-?8$HJm zI}7!qQ!s#*v!2*;%9@kj&9_!ViqA`QPrAB9_Z{?UzIeX5e*mmK4)Du$@alueKUdcV zvtVog%r|yktRBA~#>;avNP&=bF~+m6(|^S<`aS=7^SquLR7e_-#8@WmpJEtt60Qz*C* z$fkL^n!U3+<}w=JkbWljCsSt~>3Js#A@$$nhwmDVSR4z^HwF#JG+D2n_}5>jcXO`p zz3z}pgE6?^FrMD6?2-QXoFIK(U3Gj+?eqj<2lo7I{N_3$@enX3>5yLypQ{gj_Y8j2 zbk~2t)Tz@72p4naj0H31PM?8>EmH?Bo-v)EFsJ!OjHl5KF?L#i+9wDI8!a(aam;kN zH=7>PH9QC|ggld_3+q7$H!$B z<5wY0Q8dW=%Mwfl`)3yg;qvroJ}-*q_J2%|zJm&em>&J&`?KOJdyPV(l~Xgb{NAV) z@u<(Qm}#K;{LMoG<2^`LB`0IIdT8k3hAwgEZmZZP%a*al4f9G4s~c);#3nAa>bzEI z#yPgQdEUv#lEj8<1y>3I-DawRZrhvV4)tE8FIfkAud40Xw<*Y63Z%5Gnlsf0wEZce znAVTmNs4vOszbdsP}d7yUIB|xUcS;_`m7l|j_>5Xi?(B7Cw_cn$bV4x#PrPxW0-@> zyJz|9n##!gGvy4;i^0GpN>vZnHC1!*j}-mjNXHFT!kG$97B!`;Ijb$=MXs+xXE3fz+&)$hy1=^w9vB~?6(g^<3cN{fR=}rEBP=+5? z$#DA<|IcK2@Be?xaHmR!2j2a^B*T5@_`e~;zfj3=@qa{yx8Gm(Kld55iBWLO5#Ks` z_zNyqhJSU1GMxL={rkejq*r`*z|N4bGf2fJFx-KEkt`o+FL>IASFB8KOLdO4cT!(~ z2Ke#8Un6pp7S8)da_fd;rE+=4D=Ann6>M3131T^?$|S_hTmcadbNnuH z96TOZGdV+UC_FQ8ev~s@rxTF3mXw*~_6#Z4jE{M=su_hd>|5JYaY+w|D-ACKa@D$T z7xgqmaAG_xB9qm;zoZXfB(r;;xwijVHR|I@j{4||2(b(tGfjpVZb~}e(>d9h)d_lv zNP0>?MNh$d+eJYL#BWvnO^KU9b>2aiBAwG_U*UVF{UN4oqrYGXlDqKcQg<(4v^!%G z2{E>zLTbrKbvD+_u-8(^RmbjmWqT*@2oiBJQ;OOhde^XUYfdtr9EsN2c(R)c`>e@& ziz_A(jcNC96bgF<*hcaUpzD%cj>%~G`_P(EF+tQrgn4fN{FrqkN(ty4p-M^mf!wE4 z@*Udt<{G?{`P8R9wE;Mf&cAXR;)yYrNkbtj8lv>a^>K^;uhNiFp1Yg_Ot+G0Xr>rx zb|4vqtmr>FXa6zZE%?7WXP3iwe81s3t4r>|DY-JUmW0&-jvBfCdgd{&lS?^-&;=`+ zV0ohhs1+s7wbb(m(6Khp&g{OyIc7OOOpaGG`&ozeA)6rD5@T{lYasVHjVe7$nMV~I zt$WW+7|=b*g&M+8<+WKtdIP$s{qWhjXb$HkW!W4ra_J$uG>6gy=;FKpB}N?0>NV!1wqpFBsndQvCJDA<74E%3uLda zIv11_&oyJ;gJiDF5=bDuS4qQ{0zJW0@r`y(w&tw2M#rK%YSu`~E_mlziu#|a-bbNe zbgOcfOnOhO!l~3&w$G=%QAkc5W^2p$W%bwBg_i7dp|rvR%Z$0RDh_S$GTw01zICub zA)2z5)$qfHksEZ;Vdu?N&l%G9M8` zsco5hR*wfEXhzo`umAn2-u?A>=Q;{-2lAQ@ZYy>aQQ9 zVGl|5#q70P4p(*|(azRQie>ojuf;QGO>Dcr`u0mo3-4%O9iAmjw1lBg^RaLpwFnXd zZ;3)ex1g^T)_$=j!})z|*_Zj_%A7ij^sVF3qBWv3rCa^tug&^vH&N@`)Dxzmh(%lU zwdsL~GAD#Q<#;xyUfo12CxSN-yTL5Hm$DpHZ{#hv{O$N7Mp_R5Q!n)erk39~iLHkh zyT5IX8JGP&*!}M1{@DGIDtu$KKb7%~CzMfznQ?U|xGla&UZ>$TWV6a|j&j!V8nPC( z!+zNkUPH#?cWr8_I>he3ab=S`M#k<>)qy*9W?$=#-$}U@?bK+=_v;wn_(mYm4PW~} zBbF%WG4R8&cP!tP+v;n!#b9@v8gk^mXlKu7jvrpt3*ow|epI}0WD_-EqdErLkX`6f zjA>@{CDkP%??lGf=QUZ7guo$|>J4QD$n=SQje;wz?D2keLb(R}9De>$D^+Ys&*AYz zo-ZTm1XLX%;iu*gX?c;y69+RIxV$(<|8&VG%iES*+9hiqK6Z|oyJg``89aUnuam1_aADcc{(Iga%!NLrRygva&p zq_po#p*#t-KbrS*QF4jf_A&lM&RaP9vYb(@)Nw1Vj`=BatK*&%DLWYbs2WZc&%0#~ zV0in|R@X&?ZoS5SAF%O3rnY*N`s=?Wxjb{4z#?+}%eh<69~SGH*>rdY z-a$_F+g}RReX>22QVwI*vjKee)f{;M72S9H3}E&wO=k??ux+g^kMWU|69-=AQ!n@H zl?W%2n(DI1MeT{O#VPupkJO+3?D^wmVt&@lbi07~A@**3CMlI(MNIsr3u;0XqG&>44)s6 zJ~#Zm_)h`PtW@&vdNP{y#)9Pz-3pn>wMwuNqV?_op~9|n8nq78=9G1JqBYv&GLNxA z>Vv#9WDhDVu+t$6qBrYhrv>v+i;5nRX>8p`v9bGE8cUs0a4$xctfPEjTNP^&m&WeszCL zZ;cV`n6lwxVn>u!+|vtTa#wuI3v(Lo+dB)4dFsAiSQBlq!C^MAmK=o^8$t3!&%zcY zmS^1-d~8H5CGOTonS?ny2Nl2=vWy^A8}jn+pHmmTIrO-kAwD{1 zLDqMz)iFztuu`SfBK-DJ=p6H)g>pX+rK z4`f-s7ivGhpd6Bu;$6}qxAydkFew38yIj!sGY5P#a!&5DBS^zX!*89%SjIvRjx3gZ zU-swOaUT(nBGq3Echm&DV2d#eNZhYn_VKDGFo!0i=k1qkubN%HSk8~$hHqJZv`xH) z%2;mmAj{w?mh9iK?8JNY6rNlZyXmTPRi=QJLJ+$YBU@Iies3;T= zG`^x(PI|D5c8P4#x7{IA!C0yzSNFc?~-zcUdLX4MRhW5_>i-j+)wu+tk#%wQ6|0U zLG^93=CT5{YemO;shNF7DY0o&xaF2PrS7y0;@>z;{vy`5{@A)Fh)o|BUb~~ae#6Ja zzpd1;US`(9$u&EO?~IOWl7-qG#H?Zvm^GvNXPH^+iCOhM!K~-^jwmE%-Al~+1(@|Z z&aC&SnRQC=lhGv9kO>S%D&lM$||;UONvMEa+EEm*s~g4G?jc@2QqYtbFb14O$6yVBSFU# zh&yfpWf~?q;*R-ICRJrb&7QRwleGEmm#tBSTj@{II_hm}?V^@y(2y@*Y+bT|o`z{I zDp|6a{+w$}fV^6wKZ-)lu#*wj$z^<9O+(~hc;x0_NS~tvD@uP}(-|U$$_;eCtfxOu zken00r^1w~xZ_*zl{u=PC>5q4yQl)p1@?6Z{*0nCR+v{Gu9;%#{K3P=i#q>n;q`bL zLDYm`1|bDsl4@Umt-k&jQf)9183~TyU#d{Liux2&mw0`aq&`x?%`Vj0OcANzsWS=< zuSdbt3Db5r`qM{`wEP>Z{#cGlTi!(j0V{@^gpzs)*ll_U*lK<7izYt-JFyFU#a%fe zwI)f5I>(`+B|@8#SOZb;`0lFi{`@`@$0dG0m(%$y=l3E^REw+g&-4H)rnnx}IDqtN z>_XKm_V5uls_E%E!ixPPJv@YpT_(E^MUSsx1r`TVoZSbCbCJV0+3Bjs{ZE!PryQ`Y zwc4G(A2;mGOB^5%0*tjdK@`3~Sxvv$!6@px>%l=w6a9+%l2h2!dxA3`OXO2erB%%V zSDy^$?=SBn7~DOzBk$p*LOrBXp;J+8+i@6@OSTDpqWzL0}RmIzE?|HLFhIQ#4A9sxc7LSbdeXg2xW$4j2cDm~@up0rEJsS65l-TINl6eQ zs(*Q!DG9c<&FhlThj*i5skr}IJ9bZwPR_Y2`?pWcjoSB4J{$P{lw0SU>%(jE zx$(%+LX;%Wcnt3;~fF$K~^7TevlO}*5$Dtc2eIi(PEH-l#}=1co5dcHxi-JOpv88)FOZFK=74+~;X;9qB%UJ1BsxCb0{l}Wgn z$vT(jU@JK*NQ>Zgr@KOhtk1D(RN(0%yZ!$N zJ5v#|yL(_8sO!WVUSf6P?<3zY_&6L=rbBQ@iGTX2XIX~vxZ?nQ-E3(Hg~n+is|31( zn8C^sYr0E0hR1OVG=O2-9)HcZY`lTWbcY$gI4{;nN{44Ks~nGyJYP1i&Au!mlUbs( zd8)Oe7!&n%pDi4*Xbh2h>eopBT5kT zJSHtkH3a!=)_m+HV~Td^8PHtWE^Q=SyD4r1K37O9J=Z<3fL1zDcC&9XAI)-GHIq_H zvG*3~0O*lJ7!7aS`bhLCu}GIiUsvd=29dIcTK|d+m7q$>V{O&+a>xkNU7wBxzG_R_4Ox9*e`Gr!RC~6Qt zlf7N5UXdAYGwaSv1j>Rm7UXNc%JJHpU&)R|-h6M`A9H}$erlkM*Ix2@SaFJ;_PkMZ zeev4w8*<`B2hDBYSJim!!JrX}3vd)*j#1T^bN)07jz=h{V8?wCAg$;avb z1TGwQ{92r+_VsytPbTsBzl;XRW8iqj^vKl1eLgn1#x|^oHW9>POIT3~UN6fcytz8G z4xPJY59+2N^)H&nE=12mz4Hc~WAbUfDe~rNc+rv-Pt7Req?q#66KTEko8Q z?>UUki4?b?{R6Qd$C}z`jnOIo4l^0@=P6k~@X32nHt&ftqu+W5u>X`05L z$bB*&_%6NV{;t+f8Vqhxx*iuJuGCG`+i7G`f{W@CYW9r zvg<{YIP%GS-KtceXwFa9nQur)L#IsF8M;e()jti(zU>B(g?+QL1Q6N{7W8kWtn&0) zL3Vn$U#sgL{BDZXI!*&2GW;2k#~SCGT{JphdeDEPo+pPgPfriIP|eqh&uP8Sxz%(o zQC;=-VqKO8^JN#k`h)9R>An#hgRjH*%K^XmOY3XdA>Q~4kLTo^k?&`JK<@m#Ibz{f zeQ&&csT>HF7~PUxoR}URo|R2akr}36!}qOw_VAui{9QVJ@Ab-iQ=X_AOVQOZ0^bl_ zY~y<4Xn9o1(xZC2$#EigNj|lggg7@DG-DrW3^68@*j_J<4%YNXXyzx!wzN7-< z9d>cr=1*!H(K1p@rH)On%_M{$S()$obnOG*5ZoWdwQD{tS+NYRl}d^zd>Yp<2@$QJ zn#I`jMjJkz(|c4ze!VA;3jG#qZ%RN;Hx&r~iRSw-8#WR#6=iGaNTS5icpO=Yqy0m=FP@7y zTGOYwv+}cB|MYKJu2|294QVS^^yigpAU}oAxcodhq*HW#%}$0x2d@#S zH2YTOi=QLsjq>llTH>+C=hnW3MwlcMPyEB;m5H40at2E{XA$vlGoA(=*8bb1>Jl7!1m1E4tlU2)< zwc>NHH+E*3Z4%E5&3x`T9d@*TbWDc_E`tt@C)%gOq@hQuy>!Uuj>`#sCuOXlLrZh6 zVg4erYiWJ>cstsk8go35+d0Wt>w1z|^$gK59$nLNiW6gES3k9`N1)lj&`;!mL;6egb<3iG151@jlpm|9f4V3c)g z9yPx}S;cJo!r4>j&dZ-Mb(($Qj8W`sbkb119;H<3<}Ie`EL@gK6T~z(%%tgY0xBi0f*IbWF=5+1Fb&xh~_)Va%5p=dS zxbwAq6NyCa^T>fFAPCCs1$MPI?ICqb4@Iw}0sUpFDJe?Sf4V9(_x;V#_7D9DTJ4{P z)>NCCoZvZWZu<|duNHyx;55_=v!KTUmLyZ;j@td({}Al;`2+`(pYE(cB-N zle|Crp5Dq-h9iE(q^QQr@XiTjDa}cw<2%7(tO$AS6ZG@@4S9Kab=jSK`}q}Y*zzM5 z9{=p3AXxF6(+BBw5`E+l*$6-5N6mkiKh!@uH$($eUT^iw&1v@2jR75?O}4!#XFVgdhnU-HhJA@!HVNy;4ls9%?t!F0b%?k?V%iKH~W__eN$L zs`~wox|imM{@F#UMz6j#2;=!bww4nZ6JuOnxhb!u%*RY)EqVL=J{g>Q*wAw?T&!Mvpz0la z;%|vw>#xI~!oTqIzd)~kSj8Q_ACuqqp=U1oez|xDwSCBKE0R^-_swDN`=j6cURHg| zf6kid5~NA}R^tz+lt5UK)$3lYafu8>bn&JTWMF z%27dE^Oq43T3fv*m#n`D6}KcbE0||4U+fDt9eCxIo~BQ@;5RQF?rRt6>F~#=NiCnh zl;%dF_1e1XyD%iK?;vR5EeBzwi%2V%L8JW0oUbN)}n z-?A=6E-B#${HS^3f1XwtTd4TH&0JhIhBu#!OZx17?sEk`yAz7vkjIn!{d?qWL%%(F zJF&)e{;7{1)(Y(Fkbtrk$g3g|Y~EY?d(d!r-0}bo&8@B1vSVOv*+oHEhg7W|CJ(EGJ-0uhg_rI{RY2z2UH_p#)O-)JLfA(6qG0WZ#OH7fP&Kd2y&gSjWhMVd?Hx9e@ zAsJq-buUz*EZg|}1|-#31CY^V;*PV#G?nAb`F0mgU_I7_)=R=edouk-{7wJtBCTP2 zd{)o+?4LMx#e7DKaxsgAup~NIxSIyTKJmfIf7VClEJ%!L;CgcNLxDf~%ABWt^yK#S zhxTP^|Nkmo;_U`aCCkfq8WbW_%T$^EB$;ZRp9uGN$=m0+{xE-N%|-Xu-m0~W#@{mU zk?ARH!H@siDOTiV8kZxmAOw)()pxx94kPn-Ao}(;yg5hCHocYQE_vXSQ0+84w>{fU zv8!c2NQ8p#rD(sAv6_vHCi%JkH7WAb&VO6|meQ|{>z&-c5>d7H5_%`t&GUsy?`++x zyAV{$efes->4kTZ<}`=x#lQK@X@`4p2lU;BCKL%Mi6=j6N-gtb&QPyK8{Rm^_hZ{b z<^S^K4eZDNYP%o1epCCTZ1724Q1@l>*^l{}a7iiI6U<+BmTdV&L#sinl1$+~tTyN3 zfL-*)82#6m;t6zIvg5q@L+2RFn7a_NJgaL*|dB{}#25 zJ-BPHX=}Y{s~)Ey=Fx5pw=t*UdwDbbtF#%8t-o5HgZc92I6p;i85y7W0SbGO^z>SG zTreu(sLyIv_}GQbLB<5#_@G^*%|oTOsRC=8TCI6euQxviXm3M(mk`Sf`K4&MCr1Mj z*S#wRuAm!V$gew;+Be&Zd!x!O!C-%+?&@Ic3;EeUr1nGj2(63UiAqrJ?x8I&n9juw z8k(9&39zC`7`}(X>ZIGa-_`v)$ol#G?1^aua3P|*fa3l@?5A@Yv(BAudV5dL{i!|2 znfGf@P@P=gqw{Zl@~BFz(2|F=(M3W-dMClzkX0G+M3?nl8@rf4h()DfZno=(*0=Wz z7*lj^^uUQjHl@kg2rIrXdOyoke-*5C8I*KQO1PQPHqkGO$@3YEe@&KGYkuG{dHBvd z?O9nonuTrnEq};+E34_j6BcM@&?ZVKp|0$G$lmoo*xuSR9xok>BA&?TRA$+88GPD@ zCjR)dh5z{3Qq8#6hpz8=2az0T?jD(@^gXy&RzY6w*_x51eHgvR%J$(+&z%+Ca+;>t zT1mdxMakdAZG>+4PTv1g@Tc%Re$;XymFpza=gozaR4KJ$wh=!@j#sZ*DhXwRTm#gB z?>;DxS+@HhPQ3SB?AzyqnI_Gst$J_vZ$Vb*bf(nbRlXKqyN~>JeEd`!BaL6r#=rf) zHGUv>4f63lc0BfT*^J^qM2DB0AQM0$v^(`sAluv1Y0eo|KyO(ZjF)H`m(?O}6FKPc zHHh0hNO2qHzS~=eIk}!iezOrQK}P5eSk}#;>^eaY~7> zzt7`D-gxKGhupSP@F-WMVprNa)b)b5Ur`wD#Oh@Ecx0#!&$K|ei))!wtr_L%-YIPwg)U47&hbD3w~tMQM;RMK+% zWtGb@Q_6}jFdfxcbE41OU3q)_M)_tnUt1RkjP?P&Mm5eMJq`UC8y|Yj*Hw#`-MQ8w zJ}a1ZP~~`wQpsU)Vx%imKc*uxT3#M6X>;pCw%RV-uJ0vRv{QCle>jJI_&=3CDSNRO|?Jv_L2A8 zwyRH(_m}twWh&|@rf}0kP2xK$tZB=>((k;sT@)Y3TxlE;_DwQ&^|5WT?xlpEDR`;Z zG=??DWAJGZ~I!QwN+-IgRr*gIu}yA4hUzoKTR-`@=kcf0q9RNKt| zkG*$~i>loI$M*~a4#;IdEbzJq(7;O#VBYdFGmHvCI^N34Vg|uWc|k=pGaGIK=20{y zE3HAzu&gLOHdr&|tf|7@!g-%3odLfgOWgb30;!U*r@K*`vGVG$oh1eiW{))Zz3qYT|MsQyiZ z20knNc)fqjZAF)t_0jZt7E%y~?*z4S`5EW?dv)+xuijo`CX=f+#?>*s@U1S@m&jKG zYs&pi^s8~-z*mV$wR@5AU=@DV5Lu5KjmhNKUBsuc0UOiS53+ zasWv9jj15v@5^eOsdqX}#XCOvg2nmEHzq8^M#flJCVX-P?O1_=#x|_YrQ31{V%5=K zs-u6||1ezG1exVeNu}Y1j^&7QjS~fLx;~tz@oKe{Cs_}3o`$gtWvo)3KdI-*Q%q{m zUK@%!_}KG=mNyqPmCk>AJ=`Uy%PJpx`f#Y$s|{2)1Wyl3Bptv7y#o$xgaQdre*L?A zp`mOlPXX=PIsJYp{W}GEJs5T8^b7J;zF8-onGbtu9Z!bes|8e2!~~eFk)}tA9H1%? zn&a{@ZxI{W96rLAxvuWcB?d{d~x*vx|ao56l_gAL#4?pCYMw`-+2OX?W#wz5|u~ z$y2{~y*h3c6y~YGJ`bT#zDf)7X4EPluZ&Skb^9$)rANIM>dTR4euWOK+7num6rM)g z!A_cz!SaL+=j;pe#UgcijG|7~$hEqhWgE5R`nD-kkd%6;oxbF~a|(9;&@Nail;xxV z1vNktaqfMc&prrMHwv9owML44;55%`{ZN{3{FKu?pVR8cDBZB*HHki-akIpFPM?); z<9!GUla_4x9jTA5nH0;MsrP5Gvv7LbQhg22)>KDAeZ-CH%NSLF6r}-JuKqk zkEwY&c6oY5&ASP2x7z1{TN@mC@1i71Zd$p|1DatbQeNao)I@-JK>V&rpNGmCNL|G~ z54oRp8h$_T^WgP(7YmpM|0{hS&?m%c7I`|*ET#&8EM-qjS!8x-WVm7b57rr4RumXtGras*dQ&VRnXV-v+K5R}W&kwo6Zm_+X}qfE$8% zyZwpi&LLUmR!DuHw?YTS`hx+iT6$=Ip{i~m?Dfloj=f<-q@!IFg!yn^ZpTEyYv$`B zxmj1>y;84gSvOul!iP{YXYmJ zEYLJr;I>!bmwijB%t!pF@JBcX!??SI^ze%!w&Sq%6I4_um2?XN52!yS=4uM z;~TZ!6fb3Xrs|~M1`m0elD;p^9Ac*oI2f|at_-T*#`XPfgbu1w@_I2@s`Y6DStM~+r*Ekn}>KE>d%>G$^10W zbr14+%wzT`{k{`66rIPbgKFR4F}CJyO%1VA>ThK~HEk)<>Q+K)Q{FeN*_t?J;%02t zhs>UX=&e*PFMH(j*nW%N?)U*b#orn8Yu$#%?u#>B@((1gM`|4Qjl4&}KV5zKaWGcS z-}LaB`Dsw?5Wa(77ybtM29syc%$y5NA2ZTZGwsvore@5@m+GcMzXf`7UCY#>H_^;Ttjk&A5iEU#o5!Q9?>&_0J@-az>!-Fs#uhMcBd6l0>+pJ%? zqD7i--ly06-u?T0dPp$Tt0(W>CiJ23=@q=^N*`PQqEBzD3yoM{9+f_I#FX}`qd8>p z!9Vl(GIJ6$O|Idr(rFC(+DBMdTT_ZPo?}T`mKM^oV$UV|Jo)7N>pN=JB!McfPSra6 zW`ZfO;(3smSI((sdzWgp;ZS@>?|9y@E<>9KZex@%xvN0J7^cCI>WW&__lmpxdY=x; zWZO$@VP)lGOxi)E2mfWtCUpeW*}|^%9ZS|h9l>59`e{P(Bdav}hPksAJ~|xz!$$Bo zo%7j0)(}ZIgY8~vP4pY^*YRC1(9D2zD-{*)}76i7&NV?w$g{_ zYVl-^WM2ZT5qv^>&fXyLfZp^FNS+SSeSA_Shy7>F6QXx&2yzB+?#ie3TPv6R}?+{WZ|Ch072z%B{` zk0V+}GP;)OS+?7YR%G?3G0$o7plBnQt1>C*v7Q>x2X#6JJ|tcXc`*0U;C;~^a*Abw z|NL@G@|C?(A`9l1%XDfXbc))9l1~3VzB(M4s#_j8_uEp76!JVXkyQm_A^g6PQHbKO zB8nq>NYLV*TB)@lDB(N7FJkp;9NH=6BdA#t4Fxx`-0k_>ZzMR=ZL1c5Ar8-h^Wlz- zY7d{aNE^&nd|AfTgnR}5wjbe!^>tNW_*FtfT7GS?^Sl2c>jIpY@HM1sT-=aYFc0H5 z=Ip+a#IU5}I^e?Zo7amhL@zoI_fxKk$9y_B+wCT}hAa4rhO!j$o9!2v6OiB8FeeJR z*K#b2`U#;<1hZf0T!@lKVaR|B+pv}lST7_1`*Np6_k~HJOVe!cjrT{Hv~lQ2rqvln z2ikjfVo5$be>Uz?*Y#X2LTL)9A3@4ZSKLwXPWuuT4nFaO?&0k7?UQs^$Z}-<8?HSSX-*^UbB1dK{o)*9#sHE}hwpplJrRdF1(KEDB;HVC*~YVz z+@vnZrAiYfKl|QRq=T?SX08sPez^us*0gx@N2?>jAchCh8Q2pxoYCzu8<(Lg-!~gf zPXm?-4BY`%s`J^ZFTvGZslvFzyMxxh<!7l29(Y5y}z; zp=38lD3cY0A~Z)R+uPsvD3mpGrw^~=?(}hB0nQu#*hNLJ3pbiBQDX{84lJBu~1`LP%*hN7=LCp30R^@Zc z`n@%|RfeIoXJy|S@&?JbcKuuQt%0+ZZ0il3X56ps3sHN@^IUB~$&PoApGq<0GdsB* z&*dklTgp$$&u||t^_S2*3%pnQs^RcI?p1d^g6**SpB>xHwcnmVz&vaoz}{LBduxD( z1o`h{T7+!aT2 z56N+U&vt0jIU`!vn#%&^0^lHP)ehb2GIo@iP3hD_Zd1#;@q*U%$YBZ@#-2sy)fayv zRTzLHCyc@|pl2WhQZ(N{DQ-ZL9}5WEzA zfL|Bc{a-&DCS~`VJ}WC@>Ria%CTW`XSy@SGDQQ^g9(6xg?9Po@5KqqAn<9Cvibw&kP&Fw%-2$97kzWfpdr%wzQYUna20c zhJcNb80?=vF=%Md(8^vWC#x{jfE9*7W^5&j+b<(EopjK(iDPY^b-~(5{y{f7hr7wT z@R!Sr$%?69uNMAd+@2%nmne0q|3&?lXml-^4?yv}s1N|>^ z{gu8@y8mRmTlR4^-_H&6n?2jz#P@R(QcyVu?z|F%2WV?EI~6#lCtF)dr+Qd7<}V;R z|Mza|_&=ia%dRfPnzp3#x9sZ@Va!T8ZPL$$+E%Lchz$`~|D`P!@9U=-Mw(WG+K7Pu z%9jHd_SV7ik1#=&lwQZ2=-Ss3Cbn$@#c&y}&-huwA-|7wH6dCWcWGRi`*7PLAO<@O zB7}?s^e)z~M5;YXV>(ga?1v zFoZcO=+ef0HasFG%P}*FuOb{|ERzak4yFw*-)7ZxUK5bNANuLtR)padTsU{10GBtG zi7eJ8Us;wnrLI>l0}a6su4NbHoTgU3pJgSm0Z2b{%XjDWDt$k=gy*Fw@6VRVSWEi6{TS_WpTq=pe6w`3E4kAn`sZ4@sU6X;H~%WL;m5H_-SA zhWC-r+*YLIGo-8hV}ad!>X>R%f64K_`bg<9uIsZn; zr*9GiEl8uj9!aM!`^E5%Qm1#d5yz2dXM~7%OHP)9xmzm>W!cTraddwV* z(m;i}Qb4jXel#lZ!=4nnz292+OXGHRFkGe@RM666<&b&`tU22#3}isK50`h>R1}(4 z^#G^GE17RuD$oh%1#?2N+G||&M<5fR58(d~F(1bm(#M&)^R3nai9R1qW;Mm?Ke*C0 zColw?^DNC-3C`Z-FG8ENitj5^^CKJHoYfy%=|msvl1^(Xaz5edy4-$PJov=xhMmce z&#!_ifac0yMOa9?2xB7Sl6kp|?V3H9%8_a|V$c(%+{4`i&3j)5Kg?3Zc2)f1c*_Ob z#dM)T{&4M9d31bg>Xg}YAGgma_Xexzg0$J(GjjUj ztK9BlB&%H~XVBnkkARA!1oBn?OF68zls8XvkE&8y{(jxVU+EnF`)eD6iO(WYY=Em^ zkuj(c%^ek&l#U8B77ewFf`HLQ;-^?isFAJW2ocowL$)U`pbLi3G3VXVIH+F>99B}y ztnoXouQ$fb(DPdHxz`>)mfsXi?ji4i9fP@_hVKFD9aEHCHUjy>0zex!>_Hi-aq@A{ zYe9}2-{%)UYbrP2S^ zcV)REj^OH3n@Hw2S&H9*4;!ZobX683W}qvUPQ+c2>>#Uw&is^l4ZP0eRqip_pMc)U zQ|O(vlLGgl{#e_!+AJIuq2pAdbAM^^%7i(ziOn31#<))qH$xkn1A=&mCia9;lWsUD z`m1_F_leiGnqj2Rg_XR%*W00+AZU}k99gi#R1>@%#qbsi+~eEIK5e1q zacSYN!glpoUFAVP7!Q=cx5M}QY0@J>`1pia?-R67c{{BAghcS#>BvIY#C1x9O;BtK z*H!c~nIBP!79VfNW}Zd?wedHb@b12^R0?9pnvS7wJ|?J~@tb^AAh0%LDtpYQ2u_9{ zyC?|H!ryk9af*2!Da8sfKL=w4&$U+%e*U0e=}R@-E973R#BWBgqdAF3>Rx`Ff3N76{Fcv?QpRQEy9{m!JMoTWBeT{ zcHxY#2|i6R3e}_qN25Qn$BbiDBAMEXUfGs$Dsg;!Vf9{Nf2fb~B^@-aiS^bPj|$@W z0BBnyYNi3%BFa#3tK{?-#UBz?uEDDi}+rMB`K|HbsKa8>kwI<9#Yu6hrySI*7jR zhV*w6d~5}dyUL`3z5otGnyn@XY`AGb`*byNQ6mk><a8MWw&aXbn70}Tx)X&>NGP}HiE*|o^ulUULgVw;hK{LZ^OdFN4 z8O~QVki`+~7avS|@xeXS!LW`Ng9Zw8is=dhGp!eG3L^qwEM%LA3Oxp9)-xYxc2NCEi{@F8|KUqQ?{hn zMGG&QRnSB>598nFqS3zkX(e6$y)-f-Wy?JUdftaUcN4a3OnI{Q{%qf+(4IIy<0a^5 zkq)1o4Qx~7+YJG~}zifiN9>l=sN-zyxC*vB%4OD`r5|(Rn^5LQ52{PGvNwB}X;SJ$k+R zM2rcjll}!cO)AlXTsH1qEdmL>Voxge?@)af1XaGeJkm$|2I#GMt6vH+JENu(3d4yq zZhNGd+jBG~5BfT%&WDvbub%sLzuRoTZpW8iyZxko-4TQiJUt8VfxUqF7C3vQpFPA@%!1`u-0JLijz{@bbRR2sLOngsti3INg~|xT5x90txL+W&6zmVR%5(qI z<+}-n9Fxi}3IZx~V4ExQIHi5+^fIV{F8P>V<2C`w>4LE&99SbY;r4HfoZJjO#G~)2 zoBoAvea!*X3|7h$KKA7hb4B!ql7KuYBnwO`T2njy3+pz2f<7_}aKPtapEbbo!PX$b zWh@8$SkSLML_ZuSIw3hfQNwE*3lAr;aMVMYPl4#BPr-YtpEpU%?8i-v)Xdp4rca)p zF)ubgefs3A)VUe<^x3m!JOQOY-Es!mbHk7!0-gO%B#acRn?pV9o4t^+Clt-(89hje6z*oi*^Bng9?V+71ZiZ&p8- z;*pI0XpGTzkmnV@J$U)+JU<(KKg7m#J2%niV_vU%+7I?gfU2SVSs81idkS+4!fREe zZ@m1>u#M<5qq@ud5YczPmH-bSf}0K&-DJYWt0D#8AyWnp7>jE_ebM-0g?hUv2s*d1 zwX;9hR4;yadAjpLiO)mBj<;f)6UkNVD#K zKF(*VXELR#^h-W3l~9L+UI*%MWIfndD;@)UcEN~WXYBiGkRJF-n^- z7+o6Vcp5pLNcb7*H{*q+11FvC_6X})Ps%`Go|()ustM0{8qW1VFL9Yq(0YfdS@x-r zY7WlhzVw4(nBdfRntfLKj0}i$%Cy4N;l^KC{%db0qfRj%%5`kgYv&9wZIIbe-=VL# zJRjTen)O25&d%YnB6gN|CuDTmPJJS#zUp#p)fCz^wroO<-P}O~Doi7hUY|?=slEIv z$oH_HDktSftvh=x9J)z zX}!2kWqHh_PF34WsZ$-#E#o>B=PP_R=`1G^rD&-GCQ_R%3L%O~T0|!40WwLa?#qv~ zQkucUfOZf^Lg6!JK$T1==bnP`h5>UkvgXg7mAb$_ z1Ix#w_<3SjEJVm%C`u|V=fZm!Jr(}O=&23W5pPO21bW(}ci6r5+O&?qIU^eS3!4kx zH%)wg?E$Ch0`2OsGvuWZKnr8&I_2#iIK;Q+GDU!hj)^p|4IK$pg`L{rmWTdIxKbJNn7T_kph;`J?3z5B2xSDnkBhoD<*7& zMy81aF>M=lP+QD+-{^)<><&!0?vI}qBMSAtxCwjPt|?O+3)6(j@7mirzF2D1p7qZW zMIXxVT>T6*zmNLsFh)gXfd)fH!fyDz$-O-`dDJ*VYJdCW$$;@7h4>AS-N4^UN<;s7 zS#wkES>Sqf#nkMk`OE+Lu=Oh#Fx!ymgS_e;oI$R!lwxx^p2zVQ8E$7@_);J!b8Zo4Dq zCceMId(7rs^!;rE!dU*B^>u~skB`0O@7GmP-(Rf=W5~V>w4tB*pX zd-!M5{>=}7UeZo8Q`Z)p73fEU8nsRzKb=lj7-oDv^bhEr*C9;hR2x3k-#$;(F=2fO z{_89ThrAtI9fSWq)whe+vjeQT8SY!0cR5dz?V}w!x__8^$@DdIH*E`{pK}|G|8*%0 z#Dc2v!GAJluDMQ)Sj)@wuO=E;86>z!f2&T!#DanH3s<0B%|~uVGIPVc3~E8ZZuLV$ zuB@7{u^#?f=h64=m%?8@|MM*E{-ra3we=8%T?*EAb%J(_Nr37?-S!kb(Y|cm`A_W5 zYH0Ed8|sD4vthHY`K`-^31Odghn-gO@fNrOVjh0%w6tbM&C(n%;}%o8w`P^e{>p>h zR>O^Vez{bb;;Y>S5NMXpx~E`q``xE}^dj_?KJAy-5jQF#BD}73`E`OeSIqT!8*&WL zw%Q!>RtR`5GBh829q`rh-S?h*Ji*#;J|vAURH;(tl|fO#5#vVO=mB{=B-NyF%m*QO zG%Hglgj=8K77Gm;J6HfTZxUaKIIQwlcYp?eAlv358ssN^dVVb6?SE{eSrt|HlRe$r z?2m;7{LhNQmLyxq+y6+>-t>`El$A`hbn2mCHP2FmG5B1?S}iou4uXE!>$!XW)c5M} zwt+b+v0p_{`c9Kyg{|b&oSbaGYx)-|&kr_fQ|wH(4!m@KMA$5C54hRF^|lgYz}Wzw z&+k^-`sh*A4}zLceN2e|9;Eewqc8LeoAkNXaU@RwZQzQ?ixFKB!=RMFY0}`dEZuj| zx^Be{fey>MjCEyPhL2tNK+cQZoXmFDUQ|uZAH1%cHTMDaGgq+hVVVl4W+>dQ!~vJS zDRkXpU2+y2C$5{-WF#1NPb?Oy1zd{3_9sx7G)+HJ#eaR?lE!Amfux6S>a zYFGr2VMFeT0~_GmI<4&mFHlNO?XAc^UDD_UhU$ULX}WtzNyjXEy*Voxb;i2)Ds3QSOY{0N&L{4N4D2qja=0P3LrJbkve&(nv6?7xp_!y>iJZs`gnK}@PQxUnd^a+=~!J>e?wlyCFxBI#7O1yvI zx$%!mhy(W@$q0^(Cgt^$gj&MkiPTE_PmZN{gz8u*X1a?z)HycY$i*YIl^fx^Q8CZP z!BW0M>l{eBAJq+69x`}vj0AN7A#)HvQK8&*baAlrHIn3DhX;sMJOe%>$P4(N=AfZ$ zV)7qV0U;B9sr(<81);jwyX|x5+MiHD&zU-(GL!0K049}ndB(Ouro(_tAGClay#wyU z^Bmg2Yi5sdaWUqOX_-ypekR691VRwbx!=OO(!NXkcf)@JKg)mkQKi8J=S%+0`XDM}`QOXF^u4FQO4(~Rd)uIuYc~95{r#ugQVZz22x+O}( zc%WO^1L_PeXkM6*_CmLbii4XUP%qu6Hb%Q@(6AbGP5J)Idz$$OXi!J#&#wO|@u$ZV zgg7ywN)R`E4NX2Z9bI)z_Fd|ms{e`Wn))HdO>|AmQ%b$mDxDiSWch2ZSo8Bs$ROD` zaW8RxrQGY1N+s=0#&^mN9b_+ZW( zd4$U>C4L3uq#OIZdryH$7rqKB8s!S1WZuwEV8%P)zVe=}#?{4=jwz_+NgK_F8@`#o^o-u>AUUws^Nf$GkE zr7QM7Kv)E`OI+v1^B84b2xA0ZNZC%x%XEw|;be>-_3(u;o|DJ8D{qVY7~7J003W-X zt&$i-#t050k`;AN;G=g+d2LzbJ1LTH2Vy82ZCIxay_Vv+L0)7Y-}p!w50L%WT%Pg2 z7as$49n^I0J>Y$hc}Q8%AIeEDk1AQ+%@j9H_hOQ(MB4-sEp+}lLob6Djbm6p#hC2L z1Fu1lPh&RLt_H&ilTFGW?~|wjZ~5p$pQ78F;E^ie)a^yB#n*hg&9-)cm3Ffxo)$jB2Me5ZjpWe4<+(y5;M|HUh~_%k z9YZc`HQ)xt?Ok+~!SG}hJG310?#c|8sLckJTEae6}^bOJS}k9|Sr z>^{QNP!2#$!`XjXsU^D2a-le(gG&5IAN(4LbKwiwmvJYn%gCei{C)L$R@YedZ&oF> z;%(+OjA37C{S@#3S~bP(ghHrF?5nnwh~hr|s#8nreIY(v>bHMR;^x_#_3NH5QWs#g z&O1b5S*MWm9j9w&oZV=QgcF?*NM4$)Et^YDtbP6;>VH_Y^ALuIJZC1BPW5z-*Mr~M46q6^}9owEApy@n3AibjR z4DdOCf2=rMd9;BXozmEMHa!ZN8sPsr1k7ar+r=+=by#27t7;W`E>6NnweV3w2iOwR zbeP3qj_9lps60`l9BEBdaBYXEsJh@f-LZSWQjYXq@R49#1bcF3cW(RRfQrgq*|Et^ zYiIgk4fkStMQWAfo~gu=~Fpq z^_!KXsrIAm{C0fX&@+%RqT8>Agc^&r7?U}2_ktjTN{OS3fZkr{Rvdj>r;zYj+G#5A z!j#1@i&z|yzpi~Au`NUQz$mSLPvIy-55TD4k$Ynjjc%IJpX{}zPrKN?T<6PsM#&TF zi@DA^pvQ@=+&>xwdris9c&sr#nC&yFb5dF(_!{EOs@>{%)$D}t+C|wP%eNcl!G>q~ z{jz#|D&3Fk;-1fK*riLiJqx~I60y0b{dePez5>cArB1n~csP85`so5met_+oeQ(4D zAW+Od_id7YUb(^V@g6+?d`*4kPwFG#btM11Sel>M{>R?u`RBs2gg4qYlYgGKK{>a! zXA`Fqd1Hp%!IDU~T`|7;-{zltsP}Qp`RCvXm^y!E#w?8g6Y)FDHUFH=Uy5ZJGnZgBt$@|+Ta>l556M4|QskdUMVW`0o8+HcbG$xm>!bHA%F1)gKUZ}P+;b<- zKVNs+_C3u%hg}(7_h06p#}fLG>j*ISIM9df-&9v-esN}N+u6gqlOiDtTZO8#2p661QO*;AiAd>BhNB|$V<#?bkCzgT|@T0XfSLipxtm& z@gKk_B*VYSR(Jtznq}Wh%ky;PG{g@q(KQyOuVQbxYEFOjj)eu_RC!~fs^)E-(Ak+= zJ4VoUCejS`s+V^9f+cbFGrA{m5G( zlYBn6zd8Wc#V2Q}@mUBO2TlUV`ov9-bjw?<4}VFi{+Dy7Mn#T_J0wG^*G5nA^?zlX zp!*n0;cLBA@L!(o6HyD92+iv_z2I~17n5~rH{6y&59~MDo;h#+jEwlZ6&m2<)3c_f zE|@(X>aIcTEjg=k><6F!| z|7LYFcU|~Q;}m!jmT8 zR^_;IHHlSz2uIxY;=gY`$ZRy7ip05hdma~k=< zoIV<3VHHDG7>52dvQr++$RVKSkg%xySE0RJFod%re6@~{NaNCuIc-3iYogZe13fU@ zKeKEC@A{9r-M{7BK+z z@x;hE-85^Ho>w~hPPgTbzPqGA&d5`fz>qd>G#J!S+pK>s28cE~_El(g>Rh#P3+_>I zQ)nJ2LmgPWWy$ywgBPnWW5YMO59Ac>cM7@)FLeEXW^{4=H%rq(Ndk&G%_|Uaf2T){8;6>_2TRHwuUE?R$klL^HfcU z_$gYRv=!&I-90bPFy5;YKSe=dPzVaUCI*xpD-&S( z0gJM^b_-LkydJ;p)A8Cuh(lIa5M`?l-itt=Y5_RqRQqjh%qqNxPQbYYU-~`D_%%0fk^N8A3heLOW5Y(AJ9bA1x;5=fDVky4R}D-Vtg ztn5?xCQxYT_TKwX8^M@R#ZGl(wY$4luk9G<5_OJGDEgw}E+zWnM9<(%qd)GU<}iOa zM?f2A?*u=GUF5!z{VA3Xj2=rrVb=MHD~#Fpqk>6tNV+iJ8OBapRqd*ci6h1&7~`VA zIu)V6-9`mjtlz4;{7k>7JLb_r3%ws*#&}inm*yAzOdl?++8Eb^o3)@45VQ8o73UUn z6>QVtU=^Y*TDcKITsrE;7=+Hl0%~h&c-H9my(+c>UbPc^8hof${Zm|sJQ_o2#mQ`Fl0zKHy+8JXFQ(T*D|a8 zzE^D-x92e?jJ&$qjh1RG>v_(t9K3mSS#hQhN6*@aG?rO4Fgpab53@t)hsRj>O15Kl zKOrkvsy+@Yx>phbdA~bhMM2(FXV4NFX(DS-t)Tz0(ax{U1z@P+yJd#fYyg)c-LR6*{TT2S%E*?`iv(v%ubyX+h8|ET@a+$&Jw|Dg0B`_0ctKA53OA57&4?gpveDsD0xBzl-c z=u@s2#=nm?LN_?Z_WMwHDf|JyE_=pJjNJC0V{CzwcnhF9IRrjRjuG5?AcPd zN3GqdX8a>vi?UXNe1q6jws|Y7c3i zEh#w9y+L*>=h44V{44ka(!zcGuX@^q00= zgNK11yC?|#;IGoRsfnWd1!)a=0i`ty!MdM<_jC>NS;MoFUx`Erg7!pyV95tM~zvobpW%uR5F_>bPwW}BPal> zzovFWRc6_8Qdxq)m{q|-=idt;<_vZSP56ztKdlrJe!=oUoa3bZlYB8(leSQ_T^(Zw z_l-aFE)q(vteKVr$(*S1NGCYf?ptHbNuj=@yT>u#(Iilei#3&fd|=mD9l39XK#uoq zVA)n-i42xjWp+zpPoCZKW|Qm|GdFs* zy=9{}dy;Q@iShZf(4oaryfO64wP9YL?N$VfZzO>R-gXW^uKz9Uo8c9%Exg`J9diF!bQ5fjq<7M^$Xwm*^9aHqRBu>I*p5 z#9~;-jnIUItYaXouH$5zE1|0$8H)~eT>b2T=STg#lyvZlG|F`>lU(RHiHwWN5{zSD zo`j%MWf!W}B*o@nNWDzeLrCbH?UWL!4Z-bp8CW9qk+?gzvjgbsYT-EoJUqvFcn-(9 zC`x&~k7CLnW^e9ZevoHx#z}IgBrvzD7KL&j05a{Zp2Fi)w9WS})>WD2u zU6XTyJn0G`(yX?h6MYuUhW4?rw6?F?TnfdF8$;RlC9$VhaRGIh%PI17QciE`ZbWEQu$KQ_c77vj&G|tUhaC_0LP(FART9s%Q!)t zpqz251>;`BLXs<7UulZbjEkF>F=u|ptjQUvQ|!;sUOm{0ScuGM3;_mNhv&Dt4CtRy}s>?iyKdt)}G5vpHS9*hiM{J{^s zXOn(TwxLl)Z@u@yx3r(rg@T*x=Y%>4pEI<7ncmkG@AoA9y67V<#=FK^!4AY!2AbRo zg%V}kkBz&TT++SLLzug#N85(xEmIi>>U4QhFEKYcJ0Hfx$9pflrsLJDgO|b}m?h$~f*hBOxzIdirad#sb%3ZLETDL)ruvkelQ9g=Q*3<2 z^#_81a->; zMUh^(1ULwCLt3e5*s!tVMkw=1USYhZI>?8}2)?6hEX&^{-XW+DVMA}b9`LwTZS)^> z^v{MGa={l0SgC>X_i`TaGuIXzwXR7y0DK_ZC_L3aVCjK%{@#bBvNu-~9`sADedc7j z)Boekr}}6x8GDcyNd;<_?rGj5@UgAT|6>2Hshv4|<>ig6@A=@mXHH_@a~RW|Uckuz zNEqdpP)_rzGMl9n%Sxn^0sluQfCy}sPTX|%6XM?;jF9b_VejhX?CdzczqJ*(=-HsL<)va58z}o1)AG-=5 zlXLe0O;D`kV0g`J1$6le{{j<3x!?b%H`U+5KR6rUI}?J2fB}>k#oejnEKHOr_~#ah z?_;g;Bat68pzjR&(_>U*|8?ow4&D5r$t{W(>MOn5)mO^K$#jRKksq9=zS4aKp8Q#Seyg|L+FE9JgS8x|Sj!>5 zG_#fmnqAA*@8!Cdf8}1D*K!A2OU)Zi^=0c|v-&@LEkC_ld^2n5UdMqYe!A8Ny@{oy zO+;kfhmDi2rRqPCPkqX=kZ;xjcnB?9zn(m zw!wGQ-fd@>c!+Ep90Vsr(YtrNOl*USE5%WLk1*RnSEBwRQ02W3Z37dnyH#`%Yy$!T zzHqg6wK)WQY@5Tng7_dN!ka<8iHRWB3P0~co6XPNO|5Nf`xGY6y-uCyeR?xbangSeXM@y@dMo;)6eA`;y}v8lV{$J0GsJkj5^=EIb9pZX#*3^1^9h_ zw?l9~hp^Sy=&|5~bcUW>s|}+*7#^?4+sSw#?~%4@6!VDq`;hWM96b||wh}@f+JNa$ zNvl&lsFH>sa~I3CNHAxH*w-Ge*Df2cTMA))9cgzfrRoKztxUK6TC%L!E?PBDts4zp zv=X089`ORi?elkm#4aDV5(*;_sb2Pn_2s=z;!~n=NtsUMx&D^THH%vleI16O(Wr{8 zzb2+Wfl!`=DvSvcWBbaNy@N1Gxs%2Tk3_DG*gAYR%|Hqwx9sBF6nzK9zb5+3tq=&;F3Pc2cOM4Lqwrhc9#E z9URlB>&+jG3}X&3XUzfT0CUE*MF&`YLuP^)PqO)t%t%40@o(ng#D!}be-IXH(|n*P zhB_TO8gg{dr)$^AfaB~#pQhX%lu!{rC_dTXKYqQsomTxYfIz*VFeQ}4^d^Lb>#2k1 zB727UqT1QdHMQmXu1vT6R^s#Gh`916p$5|#EYh$is3AsCgNf#nQlAd$I85*A2``1$ z;g{-N|BX*aF1{qoY(DpSA8=}wqpWno!RWC<`J&(jE3;ncr$G}3>Ip%8Pa8HnfN?da zZ_|CO@Y6|GCw{u$5?_4+N(4j2a~%_fIXOD$Idr+c zA#e7?iBmGb7lnd$8WcH9gCYhr4c@Dy>nGzfT@s5I^2FlPQsE*v>(gt`8j)7{wcK&jr@I7fLsWX8z zvAqzL0dn1EP1lp-3`?C4?a{vwz7CfwP?P7tKB;=qF|6V%C zd*nG~VT&F-F7z6B^yw|@e^(98f2_nIzAotA!Q|lvjqP2%E@wclNSv?Dt%K4Z>Y3j# z+n{f1>a5wbQnThxUjQJy)ag@5`%8oD9vOMMBAV3w`sN#ohgjb1IAjSb!vHWRwk0RAjYHNSh23#np1sZ3ydLp7PZ-J;x zCj)3;4!nA`oWFt$pW8&OtxGHXt>yJ`$yxHq??_6(okMF|DG>O{hhB7RC&+;^!6RWg`)1`i&&lF;23;Q!bl~Y2Z$mNU_}$(&Uy5ZE#^iMm#$8P3NXi+I zb#B>X(I8C#gGI1r&;xfenVq`*M5h;w-k{JBP9WHa)eNN z-~Qwp`=r8BuF)B(QaY8K4odgr8daZ_lXdv3Q)ku z48^EQocMbC^F}!L4$%R1ltJeEpRv||eQH%Sq)H!ilw&EI==~i?L{I!H?val!ieSRGFe+8rk!2VDC z*W%3}niIpWb(8 z4(yGnlhcRRpg0K2L~-z2?xTJQ#$(?`esw9J^3XAV2q)JrAop~}55!o57dD6`_@;AJ zEB#KeR)&j)?%q=CO%b8Ox!lM6Hb}inU3F8=YdNjZeU*uWA-$9a4K06#^V)7O=j}Am zhl2T4SgyYm-K;i(r-ST1*a6r%-fL~w`^G`;%rayNjlY-Pjm51Dpg6{gSpG|VBmePE zP%JAFl%3-3DpQp1jCI|=PZ^NRp%U2M`2nKvT?W+ef-8)ND@1!Q?1sgbD9s<30mC6b zc2VxdRQ;AxA87m~(Wlc?;7N$RYPjg^RN(O9bzEJ00CS$kpN-B#<0YjZ=#SDqGEd8M zy+5Bvt_RTX*TM#(^EhPadXSlPf1)tp`$v`$7W`Ov1AcFM|6m_C*WKZ+b-Bg0T9fNI zMo1imG0-`7r4^=&C@_H^-(Wv&aO{}Z25LUH!SHmU41Sf*b5nf@-Jb$u1unIsBo0Pu zMICRUR#b1eKc8y^O)xw9PIxK22fxa(dCog@9gv)2*mMDSLWInln&`NjIRg^TwmIsm z<3j%6Ez8O2E^-oeM0j4ZM!1G@4u!n-fXo3KmSu@v`NQ~v*$CnjY+BOW^+LfJ-W(%4 z+pHp$eKQt>`*}G7>aK-b$T*Lmb z-|bzh)rJdzv2$P%WdN&EDUiDzq<~=>9I39T1-&TuovxF{L1Bs6+#Ox#jw>Ty5WMZ8Z1?3IV>%J{jWdryQ!P2SA+pbUl^K-fNS}Y# zfRlRppSlLjMQ9hJYN*tA2MtkMw(!0Gkda0B!+U&1`vSK>1 zDizm$FW#uG%XY!jR{YdvcPPixUSC{xZ}xek3!b*(w}ezb#M6Ss!}S(dT_4ww$8f#i zHPAth+~~YkQ$6-s}fYO6#;6Zb*wQE~>h437RaAud`-J_#dZbgT)0{_i6kw< zP{9vG>*!%m2~`7F&thnKS99{$krb}Wc?-2?WEyBj7B)(W{Y!>cxDmt|1wou@jvy8& z2*U7UGX(KL=xvYs2upuzY06wwNQgp zd6lC1XBb0CsKJ7&RJDU7l|m^!xQ7pVlH_}AodK66KXy?NV&E0GS6Y>&E$h@!Wz8is z+07P|b1hJ(meP^0f13*GR62|M1cxpdrLb0sCU`+Oj)3VxV=>V3-q^HE zA}tz%=EmsEhGYY8dHIX7<)wNzw7ewyhR12${T}GeVg5wO#<>?%p>@}tCCZutMI;9k z7tAiodL@_P-0NCn@f1&(xe{3fR1gM_KfwWA&3#agCwR8sn$8)~dN%)QEFn7?97L_! zZ(Ci)PWSCi#!g$-JE6FM3#}yv!NXvr^OMPnnW27n0Ct&YV4q1h61P<^CM# zp6oY$R#wK;xe(}@JbTu>Ec>jiq%5Kc!zhf<{{c9j*hWptDI`ec6bhY2fQJNZ>?uNr z^Y4P@#e_oJLFdmt`QLXi3JnLRnFZkI6zBiTNKGf57s@$WKjB%Ip2^(rg8CwE5D|?n(P~D-fna6)5LNo zTHH6yJ8*8=ZUYX6=_AdpSM$2DhV1Q~ZtL^k>&E0cNRV0{drP`;%RU_C-jMyGdHAug zMH>5mlfy%s=*eSc`8!OH|0;6BS(IS@yIU83+Sv4x-~KDBz^Of=24kKt=F%Ty+<` z69E`y%uRxI9G8#^XE4MPKpmR1SO?N-dnsbZY3!h*h^#d=?PiH zL|NMDbbw;e1`&lMtGL3c+nb9)%S1_v?1zuMpoJioxQW9u)-*?M5cX-Vg%1j|k>l4o zt@Mj2Mqxuo|B*G-{&y3<7N*_Va`*ZMnT?h4B51kobi&}nSn}b1EJ!uVcqCrz+`(V< zNj;*Y;LhW*(X!VVa>^t)MK{9ug&<}P29OM?HKhvliyZ{z^b!QHg@y+g|LV`fC;g*q z8+FC~rzGKvW1Qo9El|j3&msg!8$_GJNBs%8ERR;yBHdK;G zEnfaW2pmDn-kH1iQNIl1Q~=}f>fO;-8g*H^KAPE8eb4wH_N!Am#Nz66bHal1q3n2c zvT+8UolPQSZ$dVLp$$~*fv&&Sj)T1FN-K4>0be1w2g;^F$yZ3^-mdwiS7kgasP(nq z_L$v(7OLue;?P$xE7>?JRzMGRsSh~GF+sAteqB6-U;y~Bi?UCsx`7psWLPl(9BFS{ zx(f_5Bge1h9Ek*Mnq_~U3pOnmuwqVnt%u;6+}22f*K}`No`IJ_%>V6eEasCuF3BA? zFe9AoQOaXgJ@v39Xf7bhjd>;d!seD@Xphi2m*O)@8T@~1&>Vk-HAwcn2H?Ai?r* zT{zDhBCS{TLR_y8Rj&GsM}2Z;lL)X!C8UYA)0|2KIW3@o{1rWjqbg-B2h(F*wH*9} zZY-EoSy!B|D-uK+>yiaL5?;e!4|GjBfsFQ5!nY!sR?TUF{sGN7zo%-+^KJUiP z-s|1xeM@umzF0Z$hS7;WzbWSZyvw}vxJ1kRt_}dnSpSUZEK>b5>hGlXBI+ZqesaDi z8EPFc@nRlnRGm${I+;)#jbhdTBmf5Ny_bFG|%#W!6c~8$x zgzs?Pf-wfBPobJ6On0YoAY4)if%ufn7%_M3NYAhNxcJF$Y`nhTA-*R+Dqtwfd8LQ6Fblc+J*i0K61V!LQPOZ82Ao7<#ve za2^L{D%?Znxo>c6Q&ZHandD!BFVy#7L9uNymux$SR&2Iv00&K~B6`L_bG;^yW7?a; zqmEkXa^;Em4C}?W?Ez{Jlq1%9_0FQl>G{uqT&0?I#D`{%i(9O-zR4d=VytNgY zlD=>Ho=09~-}HD+Q<>lACIL+;-g}L_8JhY#@Z~^Kq>_PhuY1Oqd!i}i6`pZouk*Th z=NV3{@(&j2b!&$pU+mIL`37 zUi=8(6P(zO<7`P1PV8En=MX1$g5tysLpB$5amR^W?E1*q)^TDNyQYtA6({D3Z=Xo! z#uE;#$=qZ=%c?#*ZzxmSYAm$Gz7hvU%Y85$*ut@i$6aw?Wuq%66-YQR$F(-k$~dsA zp>^{O(<&_-2lh)>>sZ8r`LtWL;yT5FVfhe(1KT;e^x*{U23{ay%1b*eL5Yqqx6{)=8+btXtv%ALS_02J9=SMHxtYng15EW;4e} z3D@E33Valo|9NazF#T*Xk3n<&jXw`PUi&Ba^_?DiVH3}9k6>fv=eE0vXV3bPVu^Y& zfe7yjmPjfhL$E~OFf7q0fBFzC(YFb4$1KO6Jxs7fw#A4gg2D+1C01gIlr>Xj8Iy-9 zjj#uPmAcE##iryQaI6TNqTUxOf>?R>?o{x&+>MHhEFb&FP`@;vWrZYg!xnjUkLVLd zu|>-dkF_h-aQ$YTRkx@$Y*CQg8u0Z>Jhz0z<+Cs9H~c}(e5txdYd9ay9o({BU0mwW za7V)VAlsx_`@h6AZt{fldAo?=d~z>^8pldFpR1v@^Z%D|K9;L&ue#xU*s6KL`J9(< zKG{Va=kwjr`b`qfCyT5F)tw{ZHPyj1L*S)w8Ge=Y*Rqb|0q4^aIlASufyzcK6`3aa zs`95-dhlR3GH3fAZN3?(37@f%xi%bkz91VGF+a~Q_j{1{Ao zy8z~AdOME!vB%W>petT`9SDtJetsWXh%Am^er!2;LjdzL@oHq}KPl!1xM2yor#t4y z`m%XXAjkYfCtlmcF+Yvhvxl~d`H^Q1^G=I#FeIY!|A0}HUuP86NSk^K(0OPax_=Y5?J?lY z?UBy#n(YO`i+A73UcjINsQd~4c2u<-jtzl&T9yvqcJWb^bJQw=&yGPukk#jd)W7ITvlky}{T8BJ>Jv{5a4iFiJ z^q$PQ8S~~rDNHO$nF`%uXC_%&obo14M#WkY^r5S7da}!!L`Q_L=gdavoxjlCpVvLK z89(X+NMTTMzT*+ z8RL_AM>TFo;eGgZk)z=IYau_)O)9oX$D}Z?EH4>t&^>0N!bQS+T)E*`;V}p2&K90W z#tZy4yh_VkQOWx}jh|#e7K(Py<44^Ec()XDxvXbVp zA775u9*2rn9Q$$M!)}^(9Q!eMY}p8o{czkUSmciVkne~x7-SFgTXG+E^>s$iG9Aml zk3Uvs{Y-r)wg^yo5c^>o<@ZCh8}=iCJb&xh51BSCgf{=>Mw@>R?*}Nz-2@8Kl>bXe zVi^mf?j9jyK~&d*eviIsEQoFKU&4YgnxOk6`?^RUm$~39vi(9DqQ%g#uI9GU*lAgmF@C53Qchfj4ENO_SPeEa;*H-c&C3J3EjAZ$5q1_NG@IP8~$MkP~u3+bl`e)3wM<}iU{7UY)f)gP5)kls{Tmc-XxPo#qb_K^3R4(!RVBoFb3fyfg zv=|Xr0HnYZOT;73c*YfY#sM^aMj`>v+;BcaC=HB8f&1i2LP#^l5Hc)^X7A) zThE_w$*5PxE!cCUNIs?JZ~^C65S! zy8su^(sN-9r$v~6Tb?J!32-V=_|tMo9MB4J!1Dwr5Z1Ns2*n8?;kw}jPTVlAGy~xh zoPcd{V$fhWoWO}!Gv7>LIDwCz_NyQGS8)PL+Yv1orA{l?u*gFe)uhf*%QQoC$6K0R zS9{By{?SQ-dMwieOP}$m$2KoptBLK1xz8^2@OR5rnp*Bw@47|VI>}A8&QQu$47|G3 zVqv{W6n=V=Edk16pWTBHL~v9Tv=Q0m=W_4#!>Z|6l)m!ipzb}iL^K%#Q)eGQ+!yJ@ z>J=8XaEwkJ=Ocv28j$%Le`@nc=yD?~KwIWgfVO_Ew!erx8|mVqyd)QWhR2n8T@?i) zM%H8RTB*oMcl|ytj;B41_v@MWL>$J4<@&qsxJ`xShjn-_L$RNTc5wh?gb20{vvW1$ z0o3UIhaND-I!FvwV}mA=7fiTQvSRCYobQO`0>Xs3W6l#ImVEep^|0%e~YEW9<_)*l|?&XYClk5Y8Q@a zim7c4ODXBRZdgk0OUoQm3$V{dtc``OexWwjlrh>+`plS@p~U3KI6=AY2i7PcbvG+N zyw;ZV)N$=AsM;Cy&uAS>eJ{IK`=a{DLnk>-koog$L$__ogkNYf(aOANUBsW)z&F`?p3pnd9`l6wTsFz=k@A3c zY~*vvb;c&=!U4Oez-eA!(eqP3lb#PXmTjKmkh-U|0WTFma1(;)1P37oKO^~vs4Ss% zR*(;cF2dDBKJ+$^(;sGclDkV(k<2)$&OyRuednwGm~|HXQUS0jvr&Ne2?vV(+aHwQ ze+2LKFBN1p#CM9xjf3tKVCgT%!U)p?d*7+Sl5+qsfbaPo+~)6n5F6F}NpKl?cluS< zV8pFgrNJ8ft14WRV@NB;QVC@Ps&_i0vJV|wt|oKC{5zyRj;#NA@aMFQIfg1YElKj3 z3S20U-$?Zz2yg)%zQ-s27z5^G^@i8z`~9Rs zD?IU1u;4d15Kkl;=*uMPT#FZ-(w6tgi8J1nm8KLEx4zyO7$&)Q*! zjes|WXHc01IMMs#USNNg%l7A7xIX7sBjGjWSJh;)?t+C;>QDdw>_J76tp>2{N^C(T zaZ}Xb|2m6pw(XR{ztzCkq)FeY^-Ze8dg?n>6lktJd|2)~1^m^u@08)CoDTw%YmXcz zeW!kozv;eHmaB{wS2fe$?tDSk<#^1K?Xwvyk;967zqoux6GZeIuB+-V3&_=KS zqYVgN^TtO?pLP?vn4?^QX8KH-3j<9 zdEVbVe!Jxu|JYVIzcQcX@8kW-oNJ7`Fdb?VycA}+>rife@o>)@upL0o;=Ds1d#A~IZM_tMc^TBy{FKM2t zN8vp6yTy5GaiK>6u9apLv3ZDZW*(H2={g~hctn11LIB*N;Gu(Bn2$_d-G)lH`FJ&H z&C{OeL((mo9Hu@-(3Y63ke;|^3C|1jj8R}ZZ;B?GM{s3~f}l66bsVE``3=LyTqQ;U z86%J5qD})n0dOe@j!c%V7Q#P!yYo-*O%QxQi#ThT*S|>J92Edp@Q7ZNg5!f1q0}aGa^lC3n)v0vdEgYX=xR; zAcKIYDKdy7Y8f{~)CQumR4wRyWfZk6qg7F>R>l2)&b!>LNn3E4|8Jar#NH;kx%a;B zdCz;6=R7B_wo->(TN`W#O{82pBjzSMb5)!vn9Pk2)6_Vp>Ju%ug7N$~7|*UsUkY@2 zytb(rIyj{ zzefL@pBjDJPL!vW|C1diJGdS?Vc~(OF|3&=Yf6q6COo zAgj@j8D)H~7p>8Um&F==@)1^}fAJ_NhJ6uZALmS(+pOld1*AJ?HTo|_bCtQu-ni{T zYV>hMkV2xSHM+s!erxoFTit`PM!#OX*h7#DFtqj=Mr-tO<&qkG$F1&R;k-s4KTR_S z58JCAkZSZ>f{uMpYxLn0erxngyT`Vq?8C*WsL{W!l-B6OX~+bK{vzen2~eZYHPCLV zfnao{nCB%mB^M1N^=BH}XijWZx0hg5HDBlX6& z{BNya=vr6Rys6hXsAs4*&YLR9)4tkN156pIH~yiWdgD#9`9pb;=fH6e(NLu}tL`y4 z6!!dY4li^L(Olt`ld7u9$&=82kZcBVev_Du;Cz-v16x9=tx(g4*$NAYtzf;oG;3md zU)-m|ai0bN-8ECX9xH4r-U_|Oh#CRpzBv>%C7})2)qCBV{YWuFdXwE|>lU8VGdSN}Xwo&lUf5LgMD7v%hAMCED6kgZw?9!^pA22f2o$&3URPTWio!hj z%k=n`pujz(qd;~@O*Vfbe>x|lrlwANNHj~(J`RWToJP=NMo0Umo75F)+^%zc?71iJv=V;D}X~fip5`;C85|S5-STl&u^?Wj)u;c*8|b^ zl-1t%gH6Ycka5HP0PMp>@QeI7je>9^9C1HSnnyR`bQ$g&)g&2*2})eWnRG zf46;CEr9chjgoqsubTq<PKGB(h)Lhh?_UjR^D0(gQ2F5T0;yry$q zSJ&nVHKf@YThsTUyx@=1D6VM{zbeOGNNYSmto0A9t8)YBYDh6rT`h42z0rGOWkB2r z#$&inMGi%_rpLpfkS5Aq8y-JZ^pEu0WEJ85NMI&FWJ49ONpB|}nJ$l^iE%{mS%G&1 z?n~OEoJlkuq8q?$9chy;DOo_)I>szK@A5)$`1BmNO)(y)tHCv1I<8~Ar)K4n# zHQBoZ$>jH4^KVRXV|Oo(`B3UW)O&oqq;(n~*7*O2bvkD9SY*AB#!R(NLHGX*VWIll zbP3^>5PLBeXTUT1TdSfS#(h6;uQt)!U1qCRW+=u~%J`)mvauTl$1I+G3mgikL|J2; zoPjV(GJYb`5h7p|&(D_OPc$K<3!m&{Y@BZu}mb5{snTnpqX(1a=PMaJbw`d$*hH-FsDI|KGBA z=S-eJ2wx=GXL~oKi~;X$A=@?JIJhk|GiiIfHmy7#GX%zy%CB!Gj`M2O7`AU@$o1Rr zY8s`9w?SS zn98w^$ngr*d~~ud=69T$fFe98N6|;ERUBVf>zb9O#FBNaw!?gB`7tH_bbz9^W0Guq zE?8bWbTs~BIv`!lIe`w~Rz1+@iCt7EoR<<)O1e{$SJa&#ue~+nTIOm zcwR22zVGC6T6d%U=TMcLKBSOS|Mr57*b66BavG4&P{ylA?F9&<`J+PqUCo8I*>k%* zu`Dtg%5B|Ka(OOY3i2%43l~?XDaRl5L{~{qi1tFX++Jt|d%+~L7Y-@LK0~$!`ieTj zjb@wh9sE<^p@uTYez9{lc>D+qAOzXJ1b;xBZ!9KP0Sc5lbUROW;(o4)NnWXs!hI^h zz7z)cP54??%OYElIf4Yx3y=V6>HT@RwGQOUX_Wd`=~SQX4&Q7H zQAJ^cX5nTmdiQ55TnghIr@NZi3PCU~nZivjmo3sTDnUc=0!8o|v$I}+L*aY)5{2yj zVPgP9VabAQ_%}}x5OPJH?S(f`J4&Iqg2II*3l>dBp!EdU0J0}fWQHJql7EFN%iy3N zQq}qdtH1{=)|ksyjhH89I0l}8V9Df|I|z8;%w%ElahF4@ZB8$?|EZ`DIvX~bT+X20 zrFvKF$JV_ONgFrLN(?`zffkAzUDz=99>J2@m{k^E;XLk|qSYEJdvT7hA8L%FO`am5 zCI-5KSW-O}O+_ejUTt*=%d828EwzcuNZm&slz6(L!>)~YyR@sY9d(M)b$ywu_bT(U zQ3+*R58>r%Z|hZaGQ^}Wzdoc?UlbPdk8_$2f6UXbcxgsTQz-PRK8U@l^(m)AxA%9~ zhIg+^q?M!Q9$};6%NXa_(seCari8ghEi{cxz14N)Dl@zNmaN`gD_lMZjqy9JT@z~Z zq(OV&Jr@1`yp3Lmc0>@l9qm)j?)da`^(O>qs9n>?b9qzf_HW8fuI_tkU9v|{8EY~Q zg)i{c3lQL#>9C)+=$j+qdFL9+;QHqEp8jrU(50u(=Vi*H$K zD02ptMZ?5gl_0o(f@fsIxFbv-58n~yYzlhA(j&Y=1EUc!1p@y~S^Ikh<2-50;3l?Q zuU#{tl-z`C(UdiC6U}%UjQx!tEP}bpGYa{^bf%71-wT3L6AW#aN!hNeN7&-{+|n|Q z`LeoT_`XV)ka97M9WC=TUKDm0PR)MoTzF!gYpnC4F%eNu!VOf7)%L8oPQSqEYnp;# zpj(pPo!A_F@}f*E{z1J&bKy5B`0Dw7VjE7QPs|SwIV2{ywt6_u%D>I+n}#}VIp{!z zP6IDz?!39vN*2soJPTU$%qk)+d|-9TaC&W)JHGHscLB7mRo)IDld$C4pXUWlBUC&L z`{Xu?24Wf!Xro{~wWnuwH>Hj8p~6P=AOF^2*g_cQXM7}W_Io7~)SIG%Y>JY7+)iAr zow&dM+~ogqT9BxbVdEyLat(fST4#BD;v0LTr@h?dbdV`-e@%pAYG2syL0OyiKl_4V z6kyfE475=*+^QfeU+$myos(9W6Vf~4TYE#ha{}dZ)Hc78Me>jCXQ%}MV$8JwJd7ZX zqpTJoTX2D9cN>K&SGl_?B&$jgOhHCXpO7_gffeuTQ(CS~6LbHu?0dP6jw`*DAtvi7 z3Ib@pNa2eqo^apjG>wjsut ze@cv>-gde|JD7jvf9ujeD~ z@j6oy*PDU_cZ5q<0JVQ-``hjfP5Wc z>m9Sc#)4!+MPN+SCxZY~8mqN+Jp{dFy{7jK)+Qs^cprs;q0tKsjhLX*bHT=&w0@_> ziKV#YImK~cS7+m(SC4}&o8KKB2L)!OqNXI3U>h?9D^x3D`&h3%c5sR=-e{p!*C}v0 z<@K0MsmC4b5n)Y>adKVq7(5l~+)}bxUQ;|%!rmLL$6jnQKsy4Wp)3<|^nbMP@fglH zgdr8$x;`QLM?gy4lkSVPdeW;wnK+GtK=qGwEw^qgUJ9=DZ_$^>ICLUN83lPI&o8s4 ziqA3wJ}a+d=I3KfUy32yh&_9YN*^imNx!|aQ5b4)xptgiE2thcV(|z0Vc{5_Q?lvU z*yQR4GKpZj2S^0ZFAI@{H6`i8biMneGoFSgl55KVksO;06^76nInj>q$M>5qy?+u$ z7K9;4V<^)dD$c5h{+L-t-MtY})rWTicH|^(I)k%)9)qD=2aq;`mP>;LX4E~dDfx)4i-1L84iVqRddqb9?{N#$+h}#GLsmbrrqac2`VWxjSaq4`D~_BXim>d z)CTi8^7>WBDEEo%N_kwG#h1nPC(lz|@c4DQbRCE9!Xl&!0axy&ofCFNEKeFgSpQ`F zSRTr767o=Up*fu6E?bxa7Y2E#9f@eAP~B1lzvFavSqyKStENd$-bei~7>=kc>i&!` z7Wk1x$)8h1r+#yJ^Y8IeRUqks7QSyWJs@jinp|%=cA&{nm3t7x$sS_X7A0zXH#>`s zfGbIvnd**8wtp9sq}?!J^Q@?+G#1;il64M?X;aA2iww5P)BVCOj<3qw=rRU}tv^}m z34=h(e*Ln9q>DE?6T`bjm_ox~|2vK0iUsSJS}gkQ*K4yFQAvw}sN@SqR6=Y=6}F7q ztbAXi`;bGQ9a^r+zhqaENrV46je@|>(~YCrkDlk!XLnVfH%oCIkB!^9Q2Q%x-EDlA z7i$E9udiXK!@9eCKZioay6Tz?(L=9k1~q8eodIfbuf1k9;uRsll;_w2OcdS_a1EVnmp zs?TP3Erap>k}K)%`FIBY?3vZTKN7Zth2-jz zzZk{&M=pVJ#hgc=a|^PM!?_NDbC>)hxn&fmQcKOz{v5RJbp@50=6ZMvPNlY~@9v*9 z$7bCr=UZ_N3Nwg&D-G)fOX-JCC^*%O8$p{~eOG*`j8m<8HryupaT*1o7aYlLjcb;3 zyJ!@(i$K?-uIiuM#((G6l zqH)wNm$={_QatAX@|+Y;i@gNceobty)$q4GCfII$GB!7IsH%DuI(`|g(WiT4>8GZ| z75hKgGeiH=zo(__9LXcOPb8lmr5^(DFMm3O`>%XF=(_YQw};$c4E`%d7xCJcM@b5h482CrpPO`K|N%s!9P`WlKUZ3E+i?e;J+lz@&Jwas=c|({i4uV7BG1Yx` z4ilo1M>Mf1uwbY%mpD&c(|F&PBqtu+&+WI%!p=o2a0S&0`z-?Qi|Do+Mjk`IaRIqs?Sd*UX3!(vu} z_ME3`8Xe17KaruDvb^HE-QP=l4h}Y#6=@D^WDXut%|W~RfJE$NxdOG=w29pXlpPYg zTb=D`S9UN+ABe{c^(d7k8_{bk&+9pWnouo9aK5r;mEF6z+W9Ofe6;&(N={@DZnQUg zO5A8~^t6utqzyM(4Q>S?rYF~wywyj^ji&i??9aV8H(G1o`9Eu7fMU(}M$cpOUpp^u zwCekS8!Z#Z4S$?Q?w`Xxt&$~0?BS`J8r;1~H5diz>;0(|Ef9MCK={pN2lX4Xw~6fR zg1_Z@=7QHRy2yb3mvqiz7N?Ljt<-7uxYcU?#MI3Y_fFLWgPzwrL& zD1ChOGl*>HX=Dr6ld!V|s0QJIvOYnWUf+D7ri)>7KaJTCrrWyg>U@3dy+c!OcvH~U z-#8{to9FY`FM=H6q^j$BHwD6xUn-j~j0-Y-dl?)GPs2a?dQ>w;LCvklrvlJ)b$8cl|K4kX`_KkU06pKrR# zAMTWV|0dCwcD!L&HPTpI%Ihw8T#Pe)sn<+qf;A`>BDr+UOc=8xTQJzPng`##E1}HB z9N9XBBYTQEvi@vPaop>v(2_(NpWS6f_!U5qXbr1Hr}I$xMZpZjPhx}jsO-5{ z!J+WAdTuz9=Dhex+GUlYMQQN8N?0OBL<$#VBN@q1C{f6i0|fC;HHMH=inPl=GISaw z^#J%Seps#|XknK`L?X>M!|$ANs(46zODTU(T-v*gCt_DW<{+KEl!5Fd9+GugG9Hqq z@3e1qu{OT^&o(?HYhMt))*gNNpKW+Z&b%Oe8Gwi6k?bc{*9=;jNO?$}V>~35n_^pf zC0lx3cYZu1>xq2OSa}c}!`@Wp^660=2qx`M@SEwUhwwEI2&+Or{rAfVYM)LZ6G3t* zH5hz85VCA?E(YKwS!05e>${1q@^x#NRo%**?l-uMJxt6G>$J)?_3LL0$L>B!>em~) z01XD#ua6zf>(|{c7{3bsovyzDlZJmt$l4i?Zj-M%nA5)=!<7 z6`Z_Iq<1?|T6AIo8=9r`=b8q~(Y5D#ue>3WU_+mCl}w}9&{plSm;c!bY-oRYHb2-< z$6$sH&6CFB861n#f6R3#ue5Gs6|fbE>yK+C1cyS=vkU_|8j>zKEDhGqN_Ef=sr)at zC`HA83+FPMMk8jFt1}~p?IC;-GYqKd9ugXsFrY`;U_jR=S-(rC7|>-(3~1fT(oZ-B zbVpZ?0WF!9w>%IAG(&{}6}}06rmNdkcB6y=-FBmS?_i1nU8bphxGM)QQVi%a&4BXAMA%#|HsK!=vAF`&XX6>oJ_VL;(KKkY&=pg1-%3@9A{#DKy8uz>SB zU6)Qf9}Fmb$18bi3~2pI?++>rXf3%3#DKz0G{@6ROBm1!I#X&4Xx`AUp=~grFm|lf z$7dBWNgM-u_Qn*ihyiUGpC2W|fCjZBpK){=1L~e5_l5Ezd7c0^36X1WDCj8e<4Ag3 zhiO|OS*^!^#Y(r%DRKu<^Ozmsyt8ABTyv#c ze}%P5fss4c@8tKIwir1s!*R9WFl)Y*T3T%}a(R(qk$Z1zYy>%{7`dkGv#U5pPRtdg z$gyrlTW7IuJoj>*&$&J40KsDIzk^}1at?Hi#X7HN&VHax7L&|Jv^@42z{* z7Q44sXR%oP*=QaG#t{M}PNRgya^J${c>aA1ixqe-qQW9SsG)N~uvpC?M|>^nVCIn%^wFoMW*L_CNZaMZ#hgz-Q&LC4N4}PBD(g;ukmIceddPZr57;^*n?24Nf_% z0|FA58=?R#IF{qD*mywpn#CEIW&$aY@K^s=(|VH}f7RGu^SuQ!iP&Kb@mG6qgZE|l ztH%BoShFB-fWO-IEHunw_^ao-$?;cTXP;PQFg)-qr^P!5i>d?s6(Z{R{x0zY=w{(O zcvO2|z?g352M#BTS8I`iuU~KWa5|KrD|GUteT?Z2mQNR$NqLw zfv+kvH6Nq+s=7YzsCPy$`?MRuSKaYXz*nW3r+JnmP`CuEjy?;1wkzPP@{FUGtfTm< zkZt5YAvLDqiZmPTSy$7#KNRFIOXV*Fu^`y+%~u^*oT}V zUc>;H;AYcv=YZA>&@_Z7_lN%Tzq2&n_L|Whkw(EbrB$&H0<;OADGbghIr-Icf2b*% z`$IoxSBd@*|E#S_{#k>8f429yCsuNdRb+?X>t1CjFdG;Ksyw!@Rm4E`>)_l0!(M=m1Ez}D!Qt@RpB&-23~#h_V*Y34c|r8^d`z(5*xnsV^em7E7vKU3A5zYLC-V|xo!x*?%Q(g5R4(b;WR=oB=)|pS}wC@lv(1# zrH?za5-9(c+3y^AKu9-c!DWVvm#KlvSj-VLx241hq3-6k19A*7J&rF6yWyWaztArB zgJ5jH5}=t(N6zFD+Oc5P+@g7oF^~XZ+5YY0K0?7n!xeT(rnp}4IYuWZ-r!?)i7+;7pVBS~ zTO-GUN5Fley!mdI&uei^_G&ejC~OUUl>9i2g23fYEf3isX28K?h52V#BG-V4-*k*6 z^4&qNA9wQW4zNVs*EKdRlVOSKA8@}TVTr&M@G~cFEFBY`hkx=pX;+@qSfchsizX09 zqi{)kdqCMD*rI}Q_3g?Q&7+SI?M0t(6FvgT!%6ETKyS|W`gsACrM*WPLYxvc)`&ez zuA6BGK1&LJM7OT>IK>+6kztMY^t4ud+y-mZglag%^yr$_|5IU&EVtpF`nqwiw(Ovz zYQX2;P^{6Op2w#DT392stSNl!?(1rB=O9?4ssWa7WLP7vn>#+gitKNw6XgCX$NFT% zTtU~XG@gNQ1hZ|{@{dLA%{86F5hTEMokrlXB-f|dM);HKrz_x4Xoi1^wE!{6>GS3k zFDP8Nu&`iSv2)gfX@#>3=MbvefJ%vUc2Ri>^2|D7Oys^m8$GoZ^%P=ngz?o+EA^#wS@(lnjckF6~?bI~B`Wex7I<;Zb_pT2gRM<|9 zJ9O_7+o{v|akpqs-6ZZ0=!1<*UilTZr*^inr@UKY3q^aXW?pHU@$b5~ zu_+W#VmctQfILpLOO!%(P2w2B9&0ftC+_rp@-W4cn>m)ee0bkuS9ORbSIbm($Utt} z?VP;->;+)SrF(<d7jwpY1B3ZAz-%Qrh%HTJGKpNJDF`* z+L3K&S=Z>2+lI!!+m1`Nq1;}V=EIFI3wu@b(XJe+ZA1CIWU6%t1)WRt5m2UxUHJEL zXIHf6b4-H!41_tC*2abO`a{fld*Y?G3E6Yxat#s3W=CNY4qVszPihl-WHzCvr#1Ma zHa4Ldw~`Rk&NZ#Ct87B=*4PE2P3Rd|`!%%*Jw1C&@=G! zFJ(5N|21wSGWCo~rhc6@&cNvK-I7ezGJBHG1;i0`*wVyn7Ls+Nt=f+Q;?XTcp0Y$g zgX?k3sdThPe$D4WaC+e935ZRHhYR{hw2yxwHeK#JVl5uCD@MSfa0dR#^>x5JhGG?^ ztCc}JwlaEN?dt8!7n!YGe{I;kO1%xXa*wvQvh88H{%wrU4zb8=__ zo%x`~xUx$`>EZ1W!DeiBW;Y9NL6e@Jw-Z|OlztjI?8+o>=ApeVV{C+R^aHvD!&o@? zjdc&jhW;&mzQ9XQzYluMmL92f8G9R2ZI8OK+7@e-9AkHmOX>bf_lQSt*459n3UG;W zX5oP_q%uhH3gV|89+&#K?!|rHroCf?wf%H(cSm)))GbCGq~qcu>KQlMqBDQjW#%|) zCJXxE5qS+mZqTN_ZP0tST42+}G0Y%iNY|qtj$u6-9IgcO=J?6po(@gIN9QgoKDov; zq1rS7!^qNDxGf5YrL zpitTDD!DXOXPWFV>hy_b4sA}+Td;lOShG-)B&;v};9t%lZJ6F=cr9y8M7RKss2>7vBviR}{2RuD&?{}a+WT^atE@3= z+2@I6_x~#~94QNpIA>2>eDR-8b2i^QW7EMg5nyFlw1Tn!o>%Uz z4_Q`PcOb+aV=#YqW!8=%GtC;o*tH?@M)S}uni?0W+y5YO-_!H&iTLx^U%!%}TReRz zNW5W)uJMZ33?U1GLLqd#z}us_4v;tanmJ@q26@fWlfIUk(+FcSr*WvxJg;sAi0jc1 zjmFV^P%lY~Ocv z50)kQyn}+a>6jnlgO~OvIiM>n+)$`S)7S&ngEs}1>pJ+$(Zk*I*ln*FHcV&+qIdo0 zUU*hLEcA00Gc@t!!S3g-YJI3a^l@G2kMKT7Yfo5TwZIEsWx)!yH+q~4)l~0iXVzHF zf-Ri4jkkPv`)b2JYsieeUTB9`mt zey})YSP)EjO$E#=B=i{aFzt)$dv{IuTyX_UMD2?Gv==;K=%aA`T`{l4?!WZ7_M2BT zc46*SU-6o;%jrH>v1=V(vjRvaT}TMJ zW66EB7dNa)N`Z~9tfa9^(~LEd`rbw%Qr07*TCslw!y1A8gN?vDM?!!82WWb_{y??C zd(!%czPKJEyvDGxF!_KfLA9ib=@SwH%E$b$ts&HQupm`9RVhS=@mvSmxBlu^M2u}J zEW8I`wir+)O-POq(oYx+g{emjdQBwg+t`R}aJowiQeCB%L#}#i(=`s9|E1ReZw6fy z5vSjedzaHF2oI6#T}Si=#>sU;cxi$;al>BCMXuVYC$jJPBH`2q{7nfl@J(viDr2mSpUuxI>c?%?(QWu2iyymZiQhTn?+lTEz9=!Iud%2V^wG9I z!6%DHc@~*A6&lyN`n{IbOg`(v&#vk*_s{y26v4gyXx855MD2Y*C~Jiq7^xwNC+$HEys1*h)qLY%Ubq9qP8wE2qLV{80TaHtKH)f2V)wCV904AHp1T1%lEmV zA>Ej5ey7;|9KR!^A3WA=QIk!0FXC%tl1~r8U!!N_ASofz;fKVIuN*+ z@B<;bQnaMR0=7nnpuY&mDB($MS)S)%+mTRfjYg<)25r-8U2DlUqTMi&XogMRE(K#U zgxJ(0MxEyJV3#9qncjlu8qr{QEOuzG2&?N$crbI6pob?oPVZG67w5gN#66bbz&{j$7?a$BVMOXH@#2Et)WUdcXV&bO`dwK$tS|mI zqNHfXtNe}A*VR|_qHi<{YXxHDiZ-se_W!>B!~jcpMoj-)wy?wEnEBhE{oc^ z&I_MgyFb^*KbOYqfzG5di+DKyDwVGAosJPka$Vul0!gs(&xi_ffAm*S6CRhKpA^2m ze}$=e^E_YuCS16&{cI!kJ69P)Kb)~@NB4s!0cf3v7|Tk9o%EB2?&-iZJXZ@vvK7^n zqRZfux6M9?pG>*uAM}$zX?!;rFm`9}f0jo)>xo#p(Ubrf$TQc0zNp_hH7q@$Jkt<# zAE=SADk{NMPVGO-9~pJfWbgh2WW($67AvZ+MdW0k8{n*>O^&ZzU79D8d(G=U^x&hy z>`IH~cubHRm5??2hA>l2(2(ZP1?S#!q`sIyG#XC*i zbk8#%hAhxGSI(s@%9Dbq#(8!((KxQ?lHw2s4(C;J!)xxQJzp7{6BneG zKliVDfN|NNcQwl2JxJa)2fgq)eK&7oJ*d~YpkDLVgiVcp!x&kV7?r|Enmzc^|ABGm zD0czfvtd$sA9Knu0m><+zzZ`YqtJdkX9TY6*nY;L!?f^*{s)(E5Z)j~*Ap*Z7=E2L zKG(FVZ{GWnA#Yx;&C4_im67@@_4>R_i=G^Xa1&ufgm2{W^6SfHZuD&KTU-=&AL#CB zFl?(fC4A$FDhgZ6a2n023E#M)H?(>L!?B={)S~Woi%`^EYuc2dhsEPG3MBKW=O4a=@|RZi1GMPuVloq`WR9E^I3h2ZXb*0nI2{GUUdnR=TkgXIX@Fg zNfRP8YZDBQfEsdGPmOEco~j!#Jsr#~05|sN?Ph)5ThLZ0U4O94d!Jsk##8v`qD&_a ziOJ}KzfTt4P?TAV0|S3YbzRf1D8Ju5+PVSgwwPyvycsu4_^YAp$du2I=5m8^0C8ixPExjE7;Lr3&}D{11X2y5~hx{pNdW>%WBhnBD?7PNjN%oGJMc zZC&+6(zoWrx26i^mt7p%Fk{7zH7}aZZN9&@zB}8o9oLne4eHaJKmWLI%3Xohrf>9s)DXJ%sbP;tKYx80yq8j*f$xsc34_6h zAE!|eUV-0nx*Ldo)4{P%2>*L>N-NV$I7e)5M8`z*Z60NF(f4D3WPg*f--1dLz3Hd=_U zAO`vIwXc9LYkyOl<;qA5MyE6Z_n1NJ2F3)xGdyD5tIZMg)jS}`s<|WU?_I8eZ@DI3 z<0yRTU}mULX3snLZSf9k>Ah zBzTqrLAQ7dkonuvu9-h`33`9eyM*R0Bf%LcE(d2|%A>CR#@3n}S5zA3o&w=8fDW-o z{D2sA)YE{)njc+uN3S($p6+`=Lu)~oE8bl|-c8?g&$IO1qOeWC9$Ey#-+Fh-H%$=@ zc^hkYgK1cXO5+^7Bt(Mt%+TvyuhxH6^X@WQB=xvCCE6PO;fpi$KkS&7GOSC%o>F~1 zu=v+%7X-bTwd~_W?a{Cv;U|J>9VtQqKF*o6x5nav91dS}26RsE3N6%Gxl!vG2Y4nP zztw#fUQG{vEo+Abtj2W*8?VhblwGf_{sLb9uDmhJe$kcDrfZMiTF@<6uoR>({cHV? zt^_wI-YtE1GMBeyTG@L+4$zWCVUJ#~oxLRpwu?h+uj)1TT64wqWtOmu!UfYcdBXIk zoEPizo-!HAhL^*#A!}z2SvxehI2w*=4A6(PRKoWfWehNFn5=Sr(d?30bDYK5jvN43 zsQX3^n>BY~iF5AsLhQquiC9#uZzl!t!wTmw0DPIN=V4 z_tJ*5_7-sAX|qZS7qDKgovKmB^ZiuA@(a;2S0JOrCK;1}{aVh0(8A))?gU!t5;s4J z+AyZa$RY=UmT>C5-6e}tktfu)6~l537?yiBwr?-J<>J9Bp1m$fdso`#qizidxZ5S{ zy)G$a!*KY!H~kwrB;N;Ch37i!zstuQdcR_D@Qv#bl7)K?^hv%C=LLV9MnQ;y-vrCF zhiS1iy2HTTi2QqD)7O>krufjcqmR9K3h|+!OJHs1)jVc97@EcKaOlAC+#SaFSuFT^ zI27{Ka_}2WLkD6sdNiLO$YIN*iAP{xr@^Gy|d1$n0=PaPCRd)lGzv0;$&V+&}q z)+nI!eLME4o){)M0&g^2y6$5Og7)Bf{f+fvc%6@r6^_~Xkb1Wk_4xef*2(X-M5NpW zGh%YxTnbH<%*S_gJLi@h+(WHhZwoS|_kR7rDZ|=^gCL|Dq|vjjGYA*aCDV6uI!sp8 zp-l~}Jbrmj)3Q9>$e~d$9oiZZ{4U!Bz3;?6+tXl)zO8&)`al{1YpokL=#t0N+;z!l#}zZ9>yXYCP3QzUjW^gqAy+WUdh{Eml1AyqxU|4I3WLi{m` ze0N}Z$3Vi5D#L(+ToVD8Gm7IN5+8fUm)}23G&HD3l-wHXDYi zg@aCUUkqd17j);yf$P9Vs^l*Fg6|(|Rr^N__X)(ca*}=2#+DPf1zpfItgs3N_IT?{ ziO6oT3pCd8OXh!3Y5>Vk8gLhQ2~fUk?irkyF+jK?-_;0vjwR*C0Vds@88l+*eLi+T zuY{3xmw3MbuG>>}^$`tlVX)L5 z*X@TuCl#kBRy2Wi*e9eCwdR>iG+%mOZ%8+wb+`v9(qD+ZtXC%J)X#{rJ^F>k_6FYZ z%iqG^YX`xnjSyRU(Hxv|$ZIq_9#ICwY7o4B`2@VZ72dWKUAy_YmcP|svYy%dK_GLq zCr^Q*Cr=c-j(eYtdsk`VPAu(x^Vij+b_HVXqsS=RI<9q@#Is$!-6$2Ry!4#)$ zHx%*3RzS4!Q*eQ6{^5HeRMTSyD*ead@4A2J4u)b5(x?G1nPe&(@g-lKrWE3i2O%*L zS=xXM>n*w`A_VIZ0mP03*UPP8(RgC2M$@_|H6<-B;|&Ot=jYYKBJm!H?cYnUfxQLp z;%c+d3OmRN!wnFp4xh&f4fJ#I?mW(<$( z8bUR5f?N?p^%@9{CX6<3849;RmXvRh1+t0nO1Gqqinf~H!+W-(kMt5Q2(2mpaox*! zwBMNUc!WK!CIR;|2ieaWVz2C_D+v+5J~>BPaWi^t(A--pUhIuQny)R5{ZAYAMZR6r z9c|F!tm*F;u)mbO+HQd|4$6EeCKeKfPa}k_(z<fGAI;sC#$Ix@EpfDTuLTXaWF&OIg3&8-L#$lYui(`l8_?D*{V6KA>y3in_#Ue1I zZG4mA@EW(5li`@of$b_d6uyFg3LE0Wxr{nAEa)?W(PRUo39c*ItxVp?UTD_bm<&%v z_>1VGHwK|K3AEPe{eHxaVJL`jog`{$$7uXcrFZn0RJrGb$*}UF#Is(G1eda){>8*{!zVR63{KqOk9|5#{9Hh16 zCTr>IHsioTBw~1^(?!#rTuV@o1wOa3_9yUKV!NZ`areGZ%l&J!4C(TI<;r+QEO}0- z&Ehs)DYfYuY)#aYgjjeUChw#kUa4KfB9{UP7OXsP8g|I(pHsD*b7D-CjoTk_9gbG` ziPAbmY&Thl6x&U3xWjYyEpHEp+g~=87=Zd3*O_Y|8~6#qpMt#e&_of@15w(sawtwf2mLDo>lM>sPxYS7(cFmI^u3n^nkKV zBg*F&P+WCVCxLcP2O}bX(e#@OOQy}9wXg(;@0_z|&zsI8#Ihi>*a-?X*_df_WVHjA zb9p4m9mvp_QQcq@3hQXoJ4sL+?}ENfM+bwVIn{0Za)U#N(q9zhDw${0%lRBs<3}-$ zG{)Ws#*(caqQ6_=Z^hdA?FWlUinIowC)p_yKoG#BD=;TMef3MGb6r>0LPKBTh5K7; zm&;^A+LHpm>`tQn z0JIWO=HQW(p~uC1DD+4GB0}TxHrd$V+|&8CO~v=;tMpJnT=g6kbUI*o43#+bdevuw&{1^^2SnFW8k1dzqJcak_GzR%?s zeM59)m@LhKLt(did;-=e|4!o}sURd_xR6a&C0kB$EU|9Wj)g3r2!OK!SZ)rlJGkYltg7l zNki;v-6qK&j2p_|)(vdjgsDLbm3!BRerrR0o8@v>Jjoudmb(uXa)&S_BCqp!6a>95 z603ayQzVzBLHq;Oz0)Z5?{%v_3*|=S{Yds*?b{^~vog3M4mLuz6Fg;|&O^@SSOM`| z=3B!CDdkI+u7h-vj)uOhIua5iRn!n2A8ODfpr7Y73PKjS54x7p;h3%^9kFkUJFCNr zB;`WNO9Q3tewleALz^%YM`rMF^F~@%SIO5^=~z=@0k>_8bHa+1@&S4YgURsYGzx-f z+dL|lj~cLTrpj!au(kMk{Bas34p80O%19DNm$Z#2?ONAZ9HI{nb{XcAUlBti=(LdU zy9BkB<72)(p_ZuN zyvbni@ucYIkQBY`*uPKZZI3u?D1*3>r4-${AIHHyuI{Y7GuA4M3@2lYxdvRveEpEJ z90$am;0>oy5Lk>(%qJ?J<8$^LVq{C5_m#oY&9)nod(cO@XyLk&XNKuWOX1+>L0z<7 z0^!n{v6|!Y;q`YU7@vTLG>lt0PH#B?3paV-14;zM`#p`8HMeE$ProGV6*4@fkoy&% z7wow0la-yMABwd)CPEw>3h5Z!0t*5SPrIKDwR`Aub~FxL&+znh9K$5R{po-HVlcRw z#HEG^o_YTijJewmx)s;bJru29HJnMwK55*T_=~Fs-c4HSV%2CfdGJa5C(-wJAd{oVqy3*W3Z3eO_#x8oBmb)0_+{?6r%jwY7|K) zpPxSA^4VrS**fL(&7=2p9UBw)d@suJiSy0BtIcQGcOft!kbI(jkG4M>udO&<^I(7# zv7Z0B+z$pKI+4s1bB}09a%$V@^8hm{p*kmD4FL$b&CA!j?OnE8njT;{GYTVUu(>Z| zKx>9Kd+qi%{bKC##}=L@{bGoDg#BXH$ig_gKl8@I<^i~5*gV{a0`!Ync$)N!fp4ht zda+;3135n|llsN{E$7^_deC>IU(C{=j{C*9`4dUIn`D#i1uh1}u#kQ+%X56UNEntr zU~Bp5n^H5B^-Z}!lt1?)D1ZO>L&#sd#MeynQ11BRYuhHp4sB8c#qL1qPh3e3}4?r9LUo%(wrks1T6oO(qxAOqA+fvDMaP zb7`NHeab#5Gp{c@Q|^TF8m-p&5)@yQpXvws#r%!NZ;hTJsG|!4JbJ3fqNxaF#ns=9 zQ1wY^Dh&H;wA-bfC-q6`J9oi8= z9+4h1Wl3eD?1 zkG1KO(o|UeRJ5v33Vi2Jk)#9w$41sCg$@ArNr3^N)yn0Y`Ziy6K7CT)J3emHCuQmN z`#%f9dD50a@zj>E+yrx;uks^1#l3>t58qDOV@mJPDB)mp zVw~WmB|7bV=fc8l?4hFOIT|MS9W@Xa|AEIA%!{ihD}BcSYvnPSOxZYeXjl5VnP2&_ z$2b^RMzX=$$)&WD_wt{A|AXXX$B>pVvY4IUeC%1Ck9{I%6WE=BaoSU4GBO5^S zK^g^HEkd^7!kQhUP&M-ochz=P@0~rD)qdo!_YTvGahAtfdEgV&YHf>cF(!pYZdljY z2)dK@-l@ykx{PC6BG`TU?w7}#S|-~^spF9Y6fq|gIgiHf3~q!RF}oKuTZP#w{U0z-ibC<*>qJ$sQjR8| zJApJFZT5i(9zztCgh44e1-8SI75;*`4U#pY@dX}3^zD?-Y3eohkZf5DFaZS||IP7Yy3g2JJ^E}%YpT9SSmZlwO*s)S_Iyr_xTbLL<^DX*56{(Q#O&j_ zX7NgUdEMUu5^c&OaYzVi1uaQVta`ccwkvoKrTV*#U-2GFc`HBwq#jC^TW+v!=>vAy zM^Ha+UV=sfRHV)YJGJ5NVPCcFp=4uMXXDUAJr3@3%5hM{_D`*AeV5h&mW+kSPZJbt zXwJpf_SD5Y#suo26kyyFRpTV}Q2I9?C-F=P!@XhbvDK$(4<)n)C*tVu&2cSj6Lq~W z*6K;;y#**1L&~4p634>T5ih; zoy}Rh%wWh$gs=oL>OX}=gmpb-AwC#Vzi~txnFqS>NSGKm$r&wBjeC2#zLUfDtIigV zzm!@WGpVh8%=81zd1#0V;CaPW)gx3oUt#-WeS$xogYtR7<3v)fznUYY+WR^=11PNU zgUKODW~Fh0HH+iK^Z$oWL;im*6eSy9@ZGDxBH|vIj@p>+k$Lc2S+6+Gm2w)ZwrJhf z0QgPUv@Zu=yTp%dNzR<2JFa}${p#|A%NHyK*;qWnbR}QEfG#7Jr3L!UWsW_z^0cBC zlD2pA^Ye}4b`+%82fCvU+rKMFl6oNxdv{|KPymG-y~tpzEMFBiDjIqrxr`O*>rYmC zknC{3e(yZm3u%40X-zupO{b^AHgooF{a0q_g`~~8;9f|4&!Kygv1j&Yx2td%vlR9U zw_9!BQmsYLbM(yqS$$r$;=FK}OH%LmcWN8O&2L-l9z0{6h{5C6X%oALyv`M{^UTX> zT!#49OF`yRpVmDBGDmVe+@`Sc>xgzb4bZjC$!1qHniIn!k?}4G(`9)t*zT1$n8%a* z_Rlvf$*P;k>OhsO{)b{7L{gRfv=7nPhP2lN>fexjku|6gmv!HKp{C2E&h>8?768wU z{t3ZOv>zXDJwff7rqKv}0Dc23^d=;r9;!2t^NQqde_}i3$@{tW<~0lP=d#voEGK#{ zuM`T*mD)FfN0NZe1!vhSLA{&L%^x-f7%L;I%tqH8y+YjucKi&&pozS6{=0vwIN$G% zBlj)YK2ojRx7^NRPXxL{>{WSYtkt>-tsx|YY#zMseMPNYfBKySBcA}rR9Ct&%_r=D ze+vH(wvZ(Y7}Z868e@=NJ>Ziobw0aSh9_K=++!52vwCz*AYKc3&QZEY8@b27{o;EB z(6>d63krOX*stYhu#Y1&nn5wp8HxC9DttGcC%^`%xAe-q@d1Mi)GApg z{^jo1n$w&yEEO)>Ujxr+Ai294WQ)fmvf!Aljg@dHe4*CO848X8s5axB3cz$2vbb=1 z$-D&+CQd`%0(rE6bdZs;;`k>sm;l^281CYEaY9{y<`f~r`E5u(*fn_Qd(!05%DOj^ z$FCdTfe~lDJvGirdHfW9$0hF8wUh$~=prcxjwK=Pik^DQ&>EhU)oMzDh9>~HC4P{O ztp{&H+*LgXSw__yC`(UyJ@SlUd+uRJoq^JJ_+5J(Z=wrl?1H7@-AFl9{rc9R;fQO? zG}@0vpOJCkti7CCSVW%F+p=ij#i=l`=m+Waf#wi=A1~IIG5>HWLmAG$Rfc7 zpyouPDik=8V8UgbNZ;h{T#~1IZUW^*>QYLH0linoebU1KOHSfMf+a^dk>tvCI&dPv z6_FDOu85pST)FyNb2QEeHb@lHt&)s*!ESCatk=Bsueou=ZZ7M?i!|$R);}L4P5Irzz(`!AX@b5Z*t)D7>>9qpe)gu_eteZWt+^(K!x0Y3MyZUVE(Ki)# zwMn)f&~{?BLlPVcbKze*cD2}qhT6~RD*Kt;6J7tMmB}NssQo;aurK(VHx|bxHokN( zHgYd>I(;u-CugedTOe zO8uCe>v}O>_W8_~^Uu?>OW%g4=gLah>yf9&@sjOM;OQC5d3uUpa^I=q>8Zh&&Wop~ zWUZQ~r(0ZMPvGh4QVJW?)xgsOT212V=~7x!NqKtUWs#@nQv3+#=|M$FNrPT;-=pH` zdCSUqdY(u#L3sT9d3sRCQl6gfam#x8=jrJlx1uNT^mxUKok)XNeB;e$C{GXC$;CC1 zz|)fy=jq9LddR0qUZXip^O3~UQ)jTx&=Z~>_=JC+o)x)O%UVL-F)Mj`;BUgy1E;mi z)5Gm*H{ZdST@Aa68po|IONMVHIBv2Xp#zxuk`3%?5B2>f!}{cYl?9I3x?K*3!bfUb z;lFgN%Ia_6KOKTHzlteE}d{sNs zV@?I+tCHuq`-hkRc0@r~>ZWpWnq}Dz=_%WOw&&!y9tO zZrzU-AhYSb@5y*W3gLS}2Z`(R3Bwp1A{8I0`wo0<$p8Eu87dpyBkJ!cb5CkN2Ru&T zGpwJ^`3#rkKCv{_0M;wvGwf0tn9p!5j5*&QI^sYIh+jDmP8Y5V(BJdpxK6$tHw;Mu zwAnv+oDn|7{87w2z+bY8Xndt@4fNmScBy5ZDe>%P#_u9*sE$`*S?=qXfh&R9`67Pt zD(Y2I|Go|k#??gXvTG?7vrP9r!2DhxtIc_+ z9nP4DY^x7AW0KCBGbRbrgnspdJVq_qYCdACJ*d`$|1a8VIg@j7GnMulW~E4CxRAD%}eym#{b^1LtiBo201LKr2zwTA~P=G1hA=6tNE2O(ruD8sE_B-_|EYpVy z-DUMFpSHi?*w0dpeW$QIztJ?bCz_LT2;Grv&F&S)6PZdjo(H!K#X8X(+y%=bY*Fp| zhrh#G9s+AQU5vTP*Rliyr3^E~d64v-B#SV1D2q1SI|(n(j&g%??+m+LUJJox&^Aae zgN8!;615D5-H!5wKTe|{__s@ZGx7b^Dj5v8{yWdbB2#_8)GSdMB1%Jrn`2NL$fkJBh|v-s@tu}z(64_PC#O9m*$^-?&O?>&g|VsRCu zqZ5$GSz(8C&X)sg1X~)(eX+;5J;ECr@_1WX0`j1Wpsvg-v#keWjL@;u>Lb6>Po(Pd zuw4y4rMfTBW$+rmcOx9rd)Hk7he9*_Q{1~B07RTd$oadYHMYD}+%)HcYr(g{m_(v%2q+R|Iv~gjs#Qj{t_}#)}gL{)QaYzO)(s~EvA}g^8 z$8i`BMJ|%Z?)jN<>t5z~M+p-%d_9En3D?sgoz->+hVTj36J%KATu*#1bP?32r8d1_ zf(nip>^-{&Pyw7D1p^&i?hr^u<<3U@{Jtt()R`m}$do@N6F@xMxIjDxLM<`q8wJ=3 zbPr`Zg^e+lOA8qU!T~R4i;7=%1Cr&jb;w%{DIPcEXEcKmW)X-l#sAuKkATYx@58@e zd+jOcQy7Fx=>wnN+5ln4G@Z9dDsYYe%T zB>Sw5G}QJiWW6(`OtGj6lL_qL`ff$~L&E8^EL+l)+pq*9<{v?%rs;@nWvCZGD}zBi zPvtf)ap+1Us6wHm65s=qyu;p}v){0*;V`5Vy=LJJ@dNdRf5s2Q?k6Ackq$WUfy`G3 z*nzbaJ-k`}xzW?4uX!T%Rc2#4Ue$q(34#Ph=)WRNiFsSu#_!o$9T!~&%ndDi*PcXc zdOi8#)`-{O%9aF!urkA4;F|x`+iuo_R-0}Vf|a_>y+yunc@}WY(?B|Yox<{_r%szj zQHj&Af_>Wbd2{9fNj}|Yi4e(9iZVokQkI7GlxbwmOQv`F$#Yg86*V63Xd5AN? zPGH)C$pvq0E3m;EsUKAc&5q$f%i!n=1P0UkeR_p{M|M$&Zk>6`4D0jdny`|0J;hUl z^seQJUjnyttS47_X$;KFKgPDKT6AlH$K*`s02V?9IhgIRf1RPVs zxB6M`hIYp^3hn{-H{YFd8EJvR>W7211j4rV8P?~@^U9&)FMRedRoS=ixV)`x1o&MR zt3>{*yao1iZI_w)Q=RJruOquX9D@-D~n_Z|Cx~=;B)v%93+mU0=HZ zpe3~kUVA=wA1a81FF-*wzUo^p=B7m*6=03=@#W(qdq!z5?YE}DvtVP$U!im$d=ZRz zOCgN7S>rVFKIPOWlCbOn@b-{bnmcdqw2}q07SDnnnX`(>`h;!J|JnpFFw~-DsPY%1 zw49~OTie|GEQ^))qMZBRa}Z*pCW zB}^*D9Ju}2VV%ey@+GurJctB|WB+$y4xA~>HBl-Q9uxumWtiz^KP%cR?P(l-}$P6 zwgZQ;k#T|10YEM=7y!lvHl$y{$n)U>gYQUiHU+(5=@DL`fzgPV0tUsD>1A)KxWJs` zCXfpZCa5`{URvS;tDrNb<^pTlUOlu87Z{8k`c{(RBBN%iHhiZ3ef8HjKSC-b861VeMu&^WSgwhUsNMVOzZjkR|9mY|9 zcPtXbQLq6q+@tiY?O-O_;Rl-}drmVPvps4#914FBT%d|eNx~jM{y>fiCB9(#_!EoU z^RKbV2A3PVIG*lXaXkC|LH2xL3WE*1&EgM$5Ai$RB3D@E_~Y%4H|GlTjbj#g+G`zi zg-zMut{R?IB?zV z%h^BQMYzKbY=ayJ;SOucoc}iG4%1#8_jHfWa))hY1g&LBY7g4sNOcq%C(Czd9R-0qSwkO;L^m#0RAK zmS=tINLoKVdmQ5qE4@1IA3b#O$L#^Q!vc*vt@D#&{t|cCbUsc@8s+(}wd0O`e}-^} zp@yT}VZ+Az7M~w?SV14mmLqqVkzR|2>op#%>KhMwc+=&zZ^^jB^5L^`?l68n#E;bmZ zVzB2fdv zBnSycZ~*F7|4`vGMq_KjOTPchc=Mo$9Z^k7iys5iMQ9FZNV#B08ldf+&88aHU9_N~UMvvk|FxQx` zqB3S1kFTZqk+ENuOU&;e2J}Sva+dpHOo#II3_4Wg6dN?|*tbA^k$cb~2=)-OwkQ!e z#a1jJoMM|Y+)>@Lm)%Y|#iE|lSZu=zHqZQobBbj>TK#4e;S_sujKnE6;(p30_I`xv zi zHpF)&wVC2H2l&n`?tQ_A^{j9-?@jm2&{C8hJeOayO>Vo&vO5Dp;QwG5X(#ZDxsLc& zsQJajYl^mgAbzohm5q6QWc*_0H+8clelebpZ>cY%8+JXk6$NA~I( z7~daR39F_@$k3jUnWN7+ft(}dY`I;7dIj^(Ob3(ok*ZoBox(i+LM_|=>X7&L{gTFG zq`fW>hgn0SwfuIG!)(H@#9`KcPNQ`MwXe?D5sHKyW+WeD!S-!L-qOiD&^#jAP;}gV zsG@|2;h)?WYd;Uo23$t$CFZ3^kA}JeIevRM$EPvYl{i)>F1O7Z4A%WIVnxg4pTB8| zX^j{j5B5TQl7=LEaLuSOYGPiMb4y6yEcVz1#s&E|BjW;w!xU?mGd0NWOm_aU42tV2 z*2!^Q=*!|d5YMe`yY9of@pa#Lz`O;d7PnaKCixsm+j^W|Fr4lA0G`9iHbqM_2?)^R* zk-*XoEjMp_G-z8d!J<#cW^1Gv-WwTrOOK>JAupnBeeUwoH#NtiT}B;j)L_)i)#|)W zmDSHjZDgr{AGS1q?D{a&Y$%Js=4Q!+M+|lD)py005@J~@N7b|8Hp!3ECm>mP7%IpTts+fxj4 zMQu+nfiQhC#Hs)3-_uftX<0TSXmyYGN9d8nrM)$+mOXn&0$@={R!W$oeN@7txDP3w zQSBS@y+*`?(YciF&HO&zTXNXi#{q~$(2HYT$!S7*g{G#zu2hqyAruE}JeAktxDTK-HP9PkQVRPVA^5Zm0eLY1qo046nP9vh)z|YoLgv^~ui0;me5P$*%6;kQUxY<1- ztRDDA{5~|U;&fv~-_9r81g}sZMUodc!K5vQ*E_8XAR-`5gPJ3TWAfMvk+>klyGKkO z42?0}lm$ZrEF>|8`au@+i!sJ)fX(EDQRhrOVl;R~jOOtrd4>f#`zXO$4-Y=hEby)2 zZITS`7&-E|!0XQo=larJNn}uVL zbwj>JZ=%>OX{;sQ4bK97*jN{e9Fw_O1WN^{lY6Du7yov;v|fKT+!^?u87f`|)x9%p z1MG36N2`exH0Xjgjqo6mV_jfIY^;KgROW&$I>C}`DE??nlr}4LDkI2FyFoSF0^pyI8ki;fn41Y`R7j?SI);Oye`2J zdASP(W0g*OQ(R#W-H3UPJ&$U1_0O*Dr>n2BtQ!cP-QPTq+Um)eQ`^Ho?kyvR?fQG7 zkUI&eVA=21-H^hG39kktXo&Gvm#}wXf_}YeGXR9`dSkV=ZWdZc=9vIJFm7nwV9@sc z@KtB(g!cqfD6_3scQ7+*Q{zglXl^v#dmt4G8(_Iv zSf2_ZOkY;=K`OP+LE+>H@JzeLZ&;Kn`h2~~mTM-QABUvwU&N1plV&Ahd(amPjO=6c>mqZ;fq?@80-QZ9tfPZu^8diJ@&|MUyrDZr5 z%z)hoI%zUy{mFw_RL{H zV3*btX!n7Cn-bE@KZSx*@nn}bCs(>|%mh|(|2o6}J^Rq)6Q+0Oo(tqYvihF?P2|AZ zEjVvYq`o)aZhoph@3_kluJxS!OKi8pn6+ua_5DL3?qUdjHr3ZbOr&%gNlNeOl^i4 zxs-PBlHx4~!@{y8u_B{la57X>yqwaL6`Cog6&j~wcKbiiz6>*{)j7Z4?|t9i^XHSz zo>}{{_FC(C)^q(nxUM?u%kRN&{?vF@2B6?rh_M}ho$WSjuk7ISo#ise_z%s@Dlp{a zMn>g5u_$9cpcKz8FwBK8VwjMjb8-#&`LmN^QWs@rjfV|NmpmtJ0N?_@m93RXG9#!t6RjM^4()RbNZzls{{Gpj^jQrclz`_z+cMgO8z#uZe2r) zJwkve8QB#hSG~sqN6|+65~G?omYD}(?g`dve&_MpSt?sVDC{}@v}(8JNPKimyp3R1 zdwOj+d0ys*5dFA-)eF17F^nqcDsaEskCkVt-1fzk^omqwV}#n8E}LXk%vQnTIM zJs}sETIGmhdGDSFD_V%MoPg=1I!y7+TgGG7o@LBClGo2MHKM{2{jEjhCR=xSy9@CI z^!UQXonFx6_I@$*a?C>mKsNLeYd}CsSk(R6a!I^SlBtyN@>A=^SNt+~UDj6Tc`$C( z+XG9(hbV~5?O_%bEie0Z;JhfhFeZ@Gy6b;64+%M|f9DCaZRvU<5E37NqGTdb-~<}- zR5Y?evOGNYnwR9`AtHT@9EmPUD%HoRrRU6hQZjTehl(rdCphLJpI{c|*{b=c|w zyU5u1r4%TElY`L?%IU-w3i%<+ci5$j%hy@Py2-6q*hK)1-F7(a-C5pbV>|BrU>67# zOKM~$Q0-;#v%N7mKp{SR^Gp3^Fv!&t36kUW&q@{IC8agg5tZ8${xcY9kiz^4boqZA z%`VISv(Rk)bm50M=Y) zC(5b^B^}s`shJv592i(4lLGgQR}zyI<})|H)NPh&Oi@gC8MvaMdIM-q58^AQpg+I2 zuY%|&*xQn^{|eZnJIOWw*1ozdJ9Sb)^lS)9kAj@MoH?`eA@gV9+@v|F5Ox|FIcJ_> z3FHD9atiX3=3wl3th09-e!;&#$G&`F<{zZ-QGaF{U-%zLKrTxgPb76!u)P2wAXwM?nbKu9iaRnje`xwSsM0=Jtn!n$xl&3J(E6#kWP{5n}+6!l%LR2 z+fFr2*>T<;#83Y_^^}Z1jh@o<*dOGF_lEw7^^^hsf&36{AZUBCujFhgTr3JFsI&~e z2bP$1K%wgQyC3YvX3BFkl=Ljp6aE<(xE?;i*XNL%4hN}H{JX4?E=*?*o5 z0qtXg54}VGpxn^!=OlmVCb{?_J7^9)#H_u5^%UIP_^=p^GWIzgafKA|v}xye;JAT5 zjGOAvCpu%}{JV69W;$M%h+bgGOUgl#LxmwGH!D9sDd#@zfo;n(L!=8SrcPq8-HXy5m8I62Dx6K~X$|H@~-l)Tj0?&m6M5v+$ISEcktV_p|681pQ5 zXd<$CW5J@4VFS-a*}>Wc4my&&+RQBDQ626L{62CTHOzC?@CX~LK)0BQBA`I+(xvH>7iIkdkv@|r{ z@chvTx%w&?-nsacr<6yIL~{WlreEEoM<(uQ>M48eFI4?J4FTOuRe^M-0qHE(Ml|^a zekU>C>_IBG(`bndpzG%q(s0s5rNgKBRN0aEA<23^c(CPHwYSfO2%9>cWWpkik)O19 z)aS-CRK7(0aJ-cNPFX7FPa{j!P56Vd)UxP5u`Kmc{{PRfd7ZJdeHWIhGv9h3zrKa` z-G}jO+zVJA@$H*t06T$JquziMaMC^8lJ?B)hXG#Rh2o(E5fRso*e z;KAQT0S{97f-bjsGMdH${mEu>V3I_d&qrM)F4nwc)^8Vsqg|1`v++htt8acRKqo<{ z-i{R3Z2@iqnZ{#^huj)6!;`q-n?Ei0#cZzVZAhg1wd{EavvjwDSZNRLvGa9om@Bo8 zYqA~NwjFqH;eKog+4VLy^ftm3^XBH_74|p=z7?0utp@)#ebb7kRX%Tn4e-lCWpkGX z)gFFyg1kK_P2 z<)^sKhx9sdjCUU;-Wb&ysup}%-S8tG=t zEQ^BCGfVyZR(Rj4;fAv&5**M5h9D-g?>mmA6MRqf?HKJ+ zLhx-y`_2*G`zP1;XK4Z6m(sw#%X;L-w2qf)*TJg`FQgnvp+~1Ia;5M>@1-^^K}!w> zn5yn*A8{w;FBCi8!amU576nmsQI7K$q_*eNI#A&xZu)&eqbi?yUOq4AxeBJeY}Trx zmaJ(-g`_I62m5>3wypf{#%!ghgxJ=HRMA1woio1FM;1;m%=k>7_jqq2!CwUa;99{o zcEwZhshNK`Gc|NaxH7TlC~$1!*ooKl%A0|XH&vFDcf6T@xI8su(pgxU>v3hK5!pRO z^73dY=gSAvG^`zNT!pv^Va@s5hQca&0XT$IOcs2kqyU)`I7i!Hv6WrZAA>ULPpzQ4 zz$Bo*jUqfNykE9TkLxLGxA}z4sQhP9deZ%BQ(r7nsrBLc;V69v5tnT8H2tT8sZ0C+cQwOVvQ)` zuFx=N>WaPm6$)}4p=%8ynd>9PtX$m@3rC@dO{{`{f6Pw5EFAz$(YRRfL|)eHC0TP8 zEy;AYtt*fRmo=m~MpAHG8;ej5{Zp8~Ls{E_o@9JCy>7-4`NugdIls9P=SY@_@Je zdw1M6=B-f?hvX@m9rmzM8Q$dQZ6_hq5;?%WL$7I}J$C_3)W}HRvc8c?e=U!18}`(u z+2n-)4Ay4)P!K3H{vYF|F^Dyh*i?;W`@kTD%%v z_88yCq`x)35;BPo_Ge0%Q$62^sF18Klbj2?DJo37V+?rB?=M!#D&-A;- z*CivJO|x}sVQ;BZD~SMiRcKR`asqFpB?ok2;+i0KF*-TV-Fers2UEO_6^_KpWagyv zb_HpWy!x;VG@A%@jPnDpIv#ix9w-=%&z$sIp-iS7R^4IAmuwNH7(Sf6*QXH%_Zn)s zY7IXCBi>Yzgra+ycvjiy?PQs8y5wcgl7O&2u+K}6k6WdP?UH4$Zw&%=liqE9L7N#k z%?f1Pm%7z2X){k3J)=`+Y=nKBS>04zSffjjt$Q9~R+udLxMH0Y5&)*cx5fpAh+faX_Ud0|y}is`y@NWxS{NWxU9M8BnF$FRVe zA4`pAEJWZ?CR5HB&rovqD9|`vw8)w7R;>k$B!3HV;HtHH0WGQOg}1|J8Mf5-Sd+y2;|uGt>n7zUgqJ&-nhVAc8`s?Ff!q z4wWTB^#JMG_*VJ5cV(pPjb;dR0At~8ZYePFgS0k6k?CDg+&N`b30yz^!S}o81~)gtIJ2$WN>i_| z!AAkObfLcN8`I-*)Fi=lKfiXCs{05Kct}z=fqUkKiI3?B;<(##Q+MOWY$D7!Bb42v zjel(obtmXBf>_cp`;y1%itbXlFpwn6rg0ap+c=B8u*%f^5PM+(cOmnfrnhk6{7WAD z92c$&q+f+8)oF54V1Nw1G+|rI4xl>XZ9liU6(CKFLYe5erqO$jFFjr1c6L((-Ru{! zJ}^)Ltg`x_+9%!B)9D%9IA8Lc&yBOCJ2%d6Q#}I+;}X-N7Pl`dg9wlEEU7qBDjlTp z35sM^0mE#0%dJPRI76T)PxO+nxc6FEkN2Lh|CT9v1_W(Js^6lQmB88Z!#dB(zH8-7 z-z7aFmFZH5ZTi;Z7w^KuKpLV#BHQDrb@^@6ppSBPDF(y6Su4uDq+Z{Mb~W!?e*5yE zOUHH0T=60hfKp5LdeFRjo`96fK+a(#~fjuYWpRW*YIfzni-;lc1Je zFt$B|C}gq#ky?58$t!kq!{DfxhP%s@qp9y=(gFe>IcvMCJnugWj3odVXu_DoX+-!g0yx;&z6(d{)*EwsvkSpmdCx2&RD%+IA)c_v2=9N@*c{KXw!Od1 zv0ITbCG2iPNHS>(1>EZt<1NbYDNO>srEp7+4Pbu4p-$gTe8&tc+_wE1T%a}&nYQ}M zhvrL-g!EPn2*!y$_M7^9SI2^LkhLrw8tr?HTm%#RF07M(B(%zpc&S%gY;N*~8rl42 zi48cmS8L_Cg-jj!^*D~v%&bWA zCYVHmxGIV})1`=uZO-<%qTizOu1ete|E-rNu$tc}TNhPwG~DQf(tR1Ndxj%|w!iI! zu9B~~Q)Ru+vfQw3!28GzeZ`=-DvjYw`=p04K^~(xHA0G^xy$OtS0>U^vp4oT%M6`b zN#uIE>Bq_F8L%Ho!&mjOw4}8{=$&os_*V{bQFxcfrryLuHtO8s{S|XvocD-imGGaXQTl+j8Iqy9lhfWSzdQ~?jSMpJN_?mT;%?Nk7qW;R5hfxEWJ zNRa!2hxx;PMoz*jq^FuNw?m0nlwDni8%PSCqloJbd=dgRP0#ud??vg)^}bepi)|jj zUMD-9$di_J^8s%)$fD<>&+`2om3pgyhI_=0t^u|3xLc+bc32v_5g#x##Er1d)Jx(Z zAV`f5(q;Nfkd2T%S|Kc(a)W;4?eYp@_k#J>?o~D*2`&3_pZwiQ;>GnH7q3`Y!(MFa z$z9CpP(m!V_E}EP_ZPB^J7THJB0W5WP*ixspM#|)PInX52K85G8$mtV2-vkTDzznF zSQ~0~uDP5bjC01gi-PRAUvYX;p?5v6K1cfw=XDo5Z?_ku|J#27?EvEUwa&(QnA@Wm zuCIk~{h**t5Uvl&o+t~7cl4^C9t-%!0KaX_cHig?a5EfP#)X$zM--D2K_zw&tA1~< z@TZye?AD+@aYzPR12`xr0u!gz%9AEA(M#j|-Rd8C+c^;7vLGZ|{AH@49cGm9yJ4U^ zYdrcB7Dl4X?m37oUm&&UPcc$>Zv)eji{E+Nk|f!yCaJ#oM1Bo(Ab1slxMmp*Y5aJd zFy3~T@osaBw?6fPW4t-PZii3ys#5UDj&aZp`eZ*0``O?PKH21_%FRU7ui$Z@#*)DG z@Oixnq|c5V9Xs)~7=C(yUB|%LJMPOB2n!%Img``DNkAd9wg2MNCYt70zdlOJN=#8J z$fkMhrf6ZTdkK05NC6*y2TT;wY?Lii_FOZorJA_%a5{kP6PH`Y*>2qV(T&cd#coDbv=s)$?GK;xYO&VbGll8P4dvXd%Ld9>fe5p*2Tq7uVv?xqd^=y)^4Ts(j5;bo#xbjfsc#daE;Fg z;cW!Bzm;${gF{~c3HpK}ZaIVbArqCTjniGwkZ0Bq+R7BDW6nS>9oY7Iy-?h|Au6ex z@yT&A8NhTXo0sm{YF0B@?YK=o1+q!w&ekuPylfB83~sDvN%jy#S(m&7Zo`FqLo{{; zRD<~1a#I@%l@ipq2ZQ)gm%1(=le>qSH@`i3JsQyJ!6K;M;Xe>yp7uiui5@c($y)#G z!8B=bHkie^lf#l#O@0BmUl|zAzbWiPB5qvZ|D5j=V;eX-J{5w$6~MoT*l30>GvqGK znr&E^IeXrs+{~;cm?o-YW4fL5MENz!sTa0ZIjjt**BY>sJln-cm#0V~@||$(pT}q7 zpMfEWVEA9JN-Ffb!GPrl-p0WC;S*1* zb@byA-qf+O6rX3}by4BCNs7r_91DCd=4c9jXk0_wcxczaA@L7V7!N))GasiNhY#JTSAD#+maAP8(eZa61*w~ulsg9dMcb$=H% z@$2?cue#RWHBkX8#QdsPU-G*iGE&|BnIq?- z2A(@|g|1z9Lf7KeC?O+pPCMu7l*4cS6ql=j?W}_bK5r`tA_YFV`L?sX1R?ym^)G}1 z^J89M$jHrN2m67LQ@^|p%_zPDV1kOT8 zde{48EnaHK6C(*mcNd|{EqLZ||WN(?Q8O|DG6nqSRdp*w6j;12XJ zZjTxqZyLt*bcrTN6U>MsZG__jd#(GK2%AbrGTU?`ujlrDH#m+V#-raw6w0sSqN=cgU3+SymlFV@C+{653wJ4X91;$?R2%lvvL$HRJt%+AYi zxylf1f}CbNn`;=3xrU(|FxOBODgq0ScL|}`pa4%&9;8T`{}x^_3Oq^DFg)#wQDiKu z)PR-daS$R}@-uduRiWYg046?u0SFN@x3>O+@p#eKJO{t&x3>I)@b{as(UZpsSDp4) z<9%>+P_Z>TGuv*R)(dX`R(Sd-sUof;BQyR6!`#Rcpe$Q=Cf;Dm6AW@%TWCA&vC+FM z11!g$Z^6@vrJ72yvh}^i(iPcrLF_W-qN|JT^XBk*qgU{{d2@b4CFIm?S}a{tH1|cd z7T^X9^iuc@5Tq-O@ei|IX`2sIHs|_XYQ{MMKLrB*?gu7 z)tspkQq>Dx2yVVE^f^nQ&lOJeseR9V5eTUcdgZ?B6sz5g%^wm+bK`qRU4nWZM6;zp zKf>OR$s`83b+I8li6a(RW{0OZK z!4U#&Jb)zITViSOeDk8j@&oKTlcf&34!PU^ zTCmh6VdZ_HzLkTUFMf?*wLAHs%DUkXmS$l+18##htgFU8Jxse3<1|`u$`4$Gh=kiw zU>IWMn1a+x`5>tGs0^j;`t(kPTT)};72J}UU=QZVp zjf!P!kpfB$*0a2oeCdhb!a?Fd|j$c0dO3jE;ACqX)PCEsaj=9~O;GMTAZ6y3sUuW)G@2Y}zXk7hyqZo=@SzZpHe{ z1hjsD7Z>Zq+?}5BnK|^r!*ZB8-oe?dI2qBi(6e6Wo_xqMShjdP{Kv_N{h(j`Sg<*g z{W|lJKZ1{ggW^)4=OLr?JNj=&!Dgsc5zoTZIE~ppe#|&~C>UMzXms%npj4W4c^K>6 ztOFV&_kpEDdc;e^uo>a7mDIvkqVxQAOmNBv;9{v<2Tnc&6S!yll~x4lj(&?I5ZIU?4vD?F(vR1NuygDyU20_cd~t|39G}A{W_qT;~RcAUHcK z$8)3MH(p+u1&2gIr?vlIiu?ULMi{}y)q(iU;oNCm@=NMC8HU@B$mL-{B_Hyb-^7~I zS*|#D`yPyQcUR#4i1o>YBz?QS6JGK@7kSVJ#>}6Z#Kv19Pp1eBO5RM6rM|`<%pxVy zD9VQD8{o#;!d^f0f4zRf0-pboib@V^)q-@ib9Khfi*ngxqJ2YoIaTn%@nRoe=ZzC3 zQ!I;kVHS)5=nc^NVMw=0h2DT*A5s@OQP?mBCYP+jbdyAkH)7EzD+g8FG^uQ`FKNq6 zQHl%+aZD9-zC>+6nPz`#UA|Fgl^ykh+TMXC0Og~|Br$sAMkCxw15FPh8rM!>GQBXg zhYbYo<=J;6)xBV+jVKv_ri4Qn(ed;e(AEgegV#JNk&oCC0O~hxAd{mmg zSR?aMOT>DxIY8`+-d-OI+)q3_VE&3gaimo*IQH{EhZid`j10w*dDBC0iIwogQw#&% z7t>iiL2Jw;NGme*JWAZ6LNIhI)@&s1#RWDJ3tIplo4pkx@66hw{81%Uv`L`+oDNP& z^r|DFF5EQ+LOG=U;I1DLJ|g`VD>JlBQu&lwUc2L+iu#^qmy24w8}wUjv7$opBGtWN zfram0?CA-Ya)t#a+oRS;)ZpBUxDbo+8+h(ziJUM`FPvi)ZBE=nubVCj^OX7!szxGF zC6O^DK6T`c&-K#O>jl^+KA5aL{O)LJV*q3=Eu=-t@~p(odfwdeRCwwb!mWoJ+XvCd zi+gqS!J6%H#-|WWF3hr-#WU1Ogj+{VRKH7qvxP34F3N%~G>d#U$^uogVOlk~S|id_ z`w8Bk)}s%+{7iBcynOw(@RDqg=ckKGX4!g{{o+-mT3%2rTBL$$nhw*n#abR-me{S1 zyvWKkV&DNBuHyI1Np#-8pMfEWpW#!$&A@Zec35YV!V$+iI_%t9mUm#uVHeq0Fq{3a zv2(K`f~)w-bBTv=70xyYqP|u29B~QMLh5a3ktY;4Bv}USlTe{U+YH`13yD<-~)?>(l&o=E2~>~ z0(R`5LEz0pGdB1L*#LyB3%sRx&IqgHJj#{AqQ4~oB>Jm1ZhFyR~s?R-Igp0JNC|YWsE-^@}WQyL$>U%;3c)n}rpQPKDD%Yw1 zUg@=$%nA!yVg4FO??TZ67t(7OEiLh4t2;t?n7Bv4@f9>iGH}d8@gw1ZvG#J{Jcccd zJeK1U(X&I*#(<8BcKN>KJmZ$kElrVplG42fB(}f{kQ@uHJ*LLOFo|k%&nTBrGWgmi^#p zd?B6JwbN+aT7{!g*>JPY`_%>l9AT3EAkx)EOuT2p8HBFaP#;E+QORZeM3)`5oOa*O zZXp*$a7Mg}=s}AgC|gd3H7n>SC@X;98~)GH{TTS&;|-tcul#O?6hJ)kMpIN36fK2ukWJgwdYzCd zbdoQMjJ!lq9dBD(%$P~QPT}5k*$AqJI-&YN6hE{$+@``MPje=@Dvi!tV>kzNM^O)Ka6X&NOxJROS1 zsKG$q8(l_!-;(&x7N*cklmYL^jf-m>WGMVD=={EL%#RC(WDvRV?+=bk0#aYcyN%}F zjnkz}x>y52z<()n(5GqcwZ>-gxQx6x%b9yu{sgj zWCmECh}zm!G-}%k&x+@p+#W!mD>}*l@A1xQ;nP+A=QnvsPWM4NE{P{LCkCAT*hcSf zI?i)v`b`TPs&jb|?A+hKp)M_L8kTc>##*40^>4$%oL&z;6G<0o!gL zKq5i|!N)9PIbC9l5WnsQHVn6+5VECf9zsZS9263m2;zh4hjpi$hq82nfz5-Hn^&=d z1|xwB@^r(9Mz<_9fp^6Micmk&^iO!>E_=np6H|iWOp5DJ||*=D09VcG5W^%JR7&MCtmm zx812x5tHEz7`nZXa1>!0`x0~%qRl)>vdK?1*%Jn3k&-&_T^z=}T%sE_utjLoAz7ss ztf98|{a$^p<@(VdSl+*3FA{enLK>@D2@=mm;Jr@lt%hJX7Z$@|yP=yE%p zKLSijT>vMmK2H6yIsqP*`1d)c%q_NCYZx#gvHht`yNA+gshN{If2=;u z?aJ3-B4K=o*Z%cKI?j1~uX5vy197MK7}yW>I8sBB^G^EduX=NRY>ywq^|2mAq#EjY zglTAUbq<)}2#mKt{{N~zP7I}E(6Mv7|xmJrdbo?_gP^Fjyb+(p9hD; zQ=MfcXWyF|90On;|0BkU|1+yOTpa~I+Ki=h{*qNNJ2xl4V0LDfAvbr?93lM6ImjnL zaLuJpN(Qr*lP)vFnHQ_a%0CT8g!L0VleyZX`iI~0v&?13sUudF@=m}ZVtMfYs&NA( zeHg?0$1R0g!JC7)Pp8ycmp1PJt(7bt zjpCh>Cgd&1K2ZLnG|eY%WmW5hJx28!`MeJq*#bO?shfh-|{zw@oM`G_g~|!nS}Q;2upymd5~-+_?v`z;rva;NdjZ8 zO|4rZ_?tBBJaDlADBC#so7~|mOK%->pk?R4@IQPGI8T(bU4@?mj{B3T@`wAPda~mI z_-*g=brd4M=TVI+1s}ad$2tr_B5FV=1UD2O?#5j{4xxj(pU`u7z`r^et6ZIAvIYh9 z6QWM*Z)zhzv@um6RQZ)u`x3U`f`Jk0yEw<-KW*)XG5ELtlri|P|5wJ~t5^&b5;0YtJ;V7Dc;eKC6TI636^#_hiQ^Vtg^c)8pkM%uBYtCn=!KaB0)5y!mv zJF*}4594E9>?|EYUX&{Scv!D2Z#7iS@@2_|)lR;#_jd=)V6I;P2`N zZM+_e;S7Wo{<-L(518l&%yT3=&k%YL>Eh?h5%RDc$dDMTR2G#qZd-gutdi{=|GnS> zg@g-sD=*kQ+$mP6ZiETm9@sg=D!o4Fp|MKB+}huErir|vLfo$c-b;`{|L?wYI>eSc z>*M@8bNaZNon=l2WcAqgR154w563?feAv`G+Mf5%?#0m_=A^PQ3GX_;Z{DyZ z$y}!#9gn}V7x32zv2*{@8c32X&M(z(1N#(P9Afm!StSgg+SvF27%%5~KhXR3OFtNDN z-x>_Ltgd_E|ATpc@gBFsVH7-P1A9@dZHMe@ky@Pb;P(*La%a42A!l8YR_j=w4*u_ufG}Rk z85=YBY1YLsj;!%S_noDOyT;1Wa2|VIN1ib1Ad2f!_?6SI`@<)1 z<4D2Z26xi0!NgIpB#TQ1gs=%NEf$f=0Oyw%OVH#8*_xQB$u-Yev>?y01kM1p0~#GT zzz@vS<1`akJ$M@kz{RJ{UI=BtP-$VK*qrwNfdZ=7Np8gaE4~wUsUs|%>4DDHZ)#Qz z2XfIPxd7;wE_I{&olCzADsIV4EfOtDin8t;!DSSyPx>znX2^bln%qcf{CY4bi9kR|LnvKHyIiqqc9-X@@86-WktCM@FA~Jq}<6#$NDW z2}%J2u8&6D-I2BrN#Ewm;T}^q!)DJGZ&rR!J>sq@JLyLYTir3|t&TXTt%nqV2h!{) zm>WTE?wB(Q!{i9%f6tsjHRp%TnX??u&lxX=e*wIkwc*!}x_m_4{P~ykPbc2j)dRrc zW+yq!)n7N->D^KOxR!}Q)C~wW;@BPoyTDHEQtGW2YWQj!n4!L z7XOwmg0cect(H^#sz2jc^$va5ZPzBpJ}B@C>Vh+0A>x20mn7NlwC?-4=pTYEtv&60 zP4jR;mkxCrU%*S^$CpB}mRJG*oOQ8>y(U|Jk`9Ah`$U2dun(F09m9ayqHALS`qouXPW{Gwb#8oKOSNvs<$HYU!)=(%QpsGc}^M& z$rulkySVY;=mFTgKo5`Mc+Bra5C28`F3-dNH3D;`iHGtw)}g;7tvwHU&99*A692UO z0I$Iv0lP{I0%k;-ZBjiiP4?L@(|cCv2imoySu(BB_{_ zNu6>wlU(@DY#2j-sv|ca@ts=2XZ^(EJF(>?kfw3J;K!YfommLqIhwxDhV5GOm5nHZ z60a_{ow`w+&(Y2y3Z&R?^7&=`IDBdUiM&q|YCuOKU`+*@-zJ7pD#=^D0RZK5Q19zT ztB;VrVM%%K?EOLp3FRUz*syAS5de@^u2#_=MHl+!#;S_++h2g7OW%@$S}*vOS)5 z-0;E)+qQ6JRX@Vg197Aj4jd_nQhE@t7y=G4e=5=!@sN>TC}Mnt6wuqX9sx7S(82&l zONtN<`RNA5GiMc>3KgZA{zaO8&lmQ8Axd%H&4G)IV8$T=m@!P^Jgkg{#nAvTS>0D? zXg54EUZ|S(Lf=&xeS`*p^-2*MzUW(jMJqG_lCn-{h|fLRXQa?@ckk?Uu7L#tyL{T0 zSaJ$8XPj`}I_8$2V_~jc@W49ime+NvV_trc$1FI&*8>-D#f0xK@<7ExWpd&EmQHKw zp%}@3;p&Q03eHN>`BUg8Z{?`+QM@6;^->r5I1=-5C-{tq8&d(S6ODXuZ z&yP>%^E!VQu6xL5HF;a|riy6i;g1jckH9>r3>}7IKjr?67U0?Ou)6(#HkblL&BeMA zZ*WD(i_pPX?RU(tfKD+tc}hdo-+g7e;kiWRKG~f^!>lz!fX!Hh1gkuI%nx9e2{#Mh z^iB;lVccWO_`b>1>Mk<%w{6~TDvSY$Off?5Vc9B|dO!ikVxyE@A@&V7<}nSm`< z@Wk0CRgc>O?sV;8f0l==(!88Z;r%9vjLe>qU#C^&H+Ru0z2Muyk=4|j)Bqg2{rWNA zclz;KSnJv2es8K;xY1N< zdIO9z=HRIN9~apIOQg}-P<&(DJo@}>MQQn&6(KE$7H!(du%^hOV^sZs6-aKicj40%Y@V@|7Cj$Z`c1H8 zX|uf7o))N|T?Xi$VKwtdHJ+0zN~cRscA57G2QRv+u{et9F=E1%VN6MGxBgvTjjN3> z^W)aQ$3Gmbf9c4G+9M^V#pr*}e`^ahs_qCs@rSjCsgaK95xwI5EliIKM)%JUGRL8? z{tOu1j`dRa72{Jw4U9}~JLzXsUx_zgfJj-)B}mU%RtjlKdBxkXy7r!4*`WX^CtX%v zN+6VPwDd(a6dL!9tX}gZRO9H?Zh%wW;nY>d;ZP3zWw2cYHj}wG`uk$+@L*3J!9) zI$^$6jWhveA?NDdLx;Sj9gXeElfFQjm9}2D(x$opz=Kn(d+i!r;iL6Y0ls;a4U)+D zpg-Sxe)p8g)sjrMr5fU&g_enIOS8nnw$$1jEmynM;x%m&5EsVKn9O!T9Oz5DYhlUX z6#TZEo0}Eb(VPIVL*~(*fQQRs#lqVHzWjUfj-prI7|J1z)<2hCE`{8mX3TbZblzIyPZ|!j zdFQe@b}In{H*??GQbx>F*HEvi=2iqGrg_HeQr}mTGy}gVb)=_sfb>;Zd*x$QL}oXY zv0$K*x^cB4VG2ZlWb# z9HUxM*w@pO*ap}^bgA16df!jsmqN??Oz%!>Gs*6%@lTb$mG{i0@@sndAzR-4t9kH4 z%M)hX()C2(1mp)-h6s}El_7;>dAPpRxm7b%Xw?iYB$+zG&#=YTZJ_{j)Dq&Z3~tZZ z($X#4W10(_tzIuM;p+9sgbNJLEV|Lr+6b*Y6Rvt;WS_ekTU6bhzJH&w#Td>`-U?H< z@4dC9pS7McTzIC;a~~G*L2M?rGD-L2S%rgP4Oledr#7w`Q*5ogGY3lkNJNcoP>1a# z)Q%}>7Y!_V?ioKw9|OV+tUVj-Pi~X^687^NZ`1g-5POU{U{$6uN$>BDuTPH{0<)6< z;n_U_PAP{V&%RMl*KJPb(C;V1k7e_@9~&o^0(IL|gtjM#IL@tr`J;{B$*ms~qRPLR zf5-gH6MsS19n_ITY7NV7JF(wh&e{_z+1ik z>W3vP7PL=JgNK_iJ%o+%s@0A1e^U)&#pa&e`Z0v}W&>>?iaoY@A=kNee_IEgQ_uFK zRF}Co(>p&;p6D?_Hzr9XZPMLmY1$W{8DciWW+8lCsQ~Qs@ zsRbYOE(qZsv}kW1E~4iRcXssDGi_a8b*GufyU1)a_Z{N~@@wuHx~U5^Hpm0Ma16kU z<6*J)=D6Pz;e8S6*tWaH?S;K8q!?E|R312iSpmFPe^%w(9 zlBFP1T+y;*ZhUjr+Dz)HjX5+yZCGku`%7QVD9m|XX6;Uj*jrZins@n{dHExSmy3wE znjw|9*Y|Sk2=3O+uU^_?1;GI?UT$^U;5Rokp)hA7IM1n&Ry08x#rHqjP_ z)h1TED5l>#TEEBE!c{JmUn%yNKC&&mzPRJNN65DD zM(6L)-t6?f6x#J3QC&Ii)$Z5blTf{_dateUhqE#x1)ECz7^2#$_ZCJUt4$L)wT#zVv}D9 zb@FL$TVH+gW1)J?9VjP~wNfixq% z>_Ia@!Ny(4XyqO=jChi48F%j^r|c`g={+!U?wmp_GFr2TfTr5d>#+GGe&xt4i;_Swv9`_d!TJ= z0gQoQyB!F}ybUo84vDybaZc|?tl}mqXJIx@Nc3!%Ig5V4oH8`3d(LjY|@ zjg!~m8yVSo?ruN-ugqN@eRh}a|Hj;XIeq_pe(nlajTr7acX7jA=kDGJr@6cERK>Nm zFn5?pDQ@om%`EBR!##dy?h2gduEU2x&BVFO{hhhffqx$iFH}QxBFnGV_EO4Fq?ob4bvx(qIz~3Ue_^~WB9qGe&q4eO@(|xv;Fh_03EKP z&%VRWrEQH=ehV?q5$l;L6s-i6l5<{!Dy%tl``Wm$ew(5mukbbsD8`5Tb>uRHE2R0i0~Sz)N0;sFm8kI z3P{Vx@4c;tjX~Q$j6rCDps>b?2x_tmb{gY2`GR8W*4^@|pzR#2#sg_`oYTDag=3y3 zlW<-`JI!m95&}V3KFYdXXG6Tl0!SFuXOlyEg^6ki{1W*{43z|bRjhtz9rNX6l~1e;XJUdx;1`J#Ui7!!)9K^0m`)ukcq5U)l-kq?qjg(Z@o9IpiZM(iIQ$=R1B z7tnD01@TpbKWHE)d-730$`>@y{lcINB^D;q_FsE#62J9VPrI6%SW%N>uun(0K5ywrg=-cc88YPpNT#b9_SAvtVs8U&_GY!PHMtH#D8?e@vl!u6Ev(FR0t$L5 zz#uV{DY0Nt3{p;nM)f&nRp zV>%cXnXG}pB8>VpoNTQptFnODMRb@rEc@bk_wI=|~LM`4K*o5rRmqvyOscIiCk z0*?D--k&b`D%pC)S6P~hWoc^NTBIqBoQSIJ1*QE^a5(6fmQgED+y=;CbRkHF^;n5B zy=qFKL30W>wlX`V{MIyct$w=} z6j%AvcS250Dc=IOW4GLYgfvc>R^ZGk^@7c@u%pD;Kj0duBqN*eNmLX;tzpS{q1JHW zLvv4Yq2m6`M-Z^=U1jU2Nf5@ibGoE29P=^`rm+z7;ol$Pc?lWI(p>h_SHQQ6m29;P zO}Hf&^0FU2|I0)$mb7%8(82Sc*cYHvqP@nshgX@BydHsl>)(eV`2zDrwN$B zP5`EqRIScfYwoS%=+hhS&&CO^@ZlH-U%4b#1=(KQ&KOoQLeqe?Nsgjp_x$J$4JPD9 z-1P!4wEX7vXODbJ8)c2nc^#!Jt~G$yK!3pp0;s?C?+>~5Turg*AUFC`^VyotINlI@ zY?XM@Gz|sewgvo1k)=HXNvlYCUfw;Q>>0n)5C7}M`1-vbY43;sotOJZ%lQVrkO|5~ zIEILWf;lG+UMav?^SFlU&v_wbKNLr%`gOz-2)xLd2Z46YGpwI^qM?4_6>~??~f~mHu47fW6Zv=aAPtttKz9k_51~D!UQ=as6dd>$!IfcY=1`_->)Ju_zaR zV~E2})BN{XDb}p*K@sXO-IXV;Q!6%Z`zE+(KERQI$nauPn>*#JKDIhzz1g&&5E`0t zn^69xL|~?BK6Nb@og_Vw1cL$|Jvc=J@M6-Y1z=w_GP!_S$hkjmJ=r|t| z1dHcYCXiSu{s|D@DhY7Eg!B!ps()lp(9X~NEiC~KZ^cvLVDYtz%+rfL^vL!&LUn|)m1(c;%!woSW|c5aoHXvpbGlTkP|PeL4H+!8(h4q`+P$;;PE4kyU>=? zW(|-U+pM3#*2=oR5>{Q9j)jWvFi`c{ymB1>#K7C8xohF3_zu|~QGYjwtLOP_p#U+m z5cY-UMur(P%@05>TcN!Q8n#^nC)maJ-aRok6c%2a_|r4HT%9!=AG_iMYccGD3iT~s ztQs`=Ev*Xl0tgBr@BV~AA?Osl(%T#Dzv|&&|Fw=bYQ6nUdu)k$ zxJB$zrS!1FKYkc%SlfbJs%gCIXnnWCd;WE7OC5U8=K{h6)G*B`yW=F`^?#g|@MPz| z|NhV@>b7{yp)NALo*Bb{?X6v-B>KsS8&?cWdtVqj(Rvu7qsEnnq_SUvE%j?)uxFzS zgXsy2*A^l&+DVvANwflOWbF30EVyx2Tk&*JG+#NyYAhK&4d^!;ggpe2-d3T z?|XnZc)0RKA<&5DW1zb6m8!gPLy>AREABQ$$lWlg=SLBE(Mdkd%~t2RG>$2aDBXq2 z!?)<&d^IkQyjj<>V31Ud;8M6YrS_a*TX?JsS@#hrvD~3Ll}}ZtxzF7~$g2eKR=QuW z@Ny%_EgQj3KDonAo;1Zn-dGJ`8`rZJa*Q%VN^NMkuzF9ixk`FCKQL<7nQg)fW#=Sr z&yZ%TP8yffk5A*uB`VE1AGYftoCEagv*wZSKn^!c7`cp3XJ63(;@YC=! z?0v#q3ZHlRcsPP9?#It1kMZjw2!fy-43;PmTbeP9a`8wEjtER8noW-gX80eE?9jrG z!6d0Gbo>~xbdNTV#FRCF?(7GS(I^3vt{q}8O*GtB8`V3S6^9^Jg^i}z2jY3m2^A$k zd1hE%(LQHedI3d6UxT%xE)1OUVqo&Jj~XBKu+6@=)}`FKLYRp?j+s!beLVc>>4kfs z_UDOhJK32iffAhxoQXIGwcr>T7=pljMpiBoqUoHqO<2YnAuZ7Z-Us2FZ0IunX|x)I zBl`&saj!mohhG8&mFd?tHR|#>r3mkh!S?=?Jw=ER(q zh0@Ndqp+ihbsS3@7N3-we&-MXuD7tV$i1se(vgj(1ipjEO1}5}2R=WN&t!)wA-Zosu zh;iZ>3MNR7=Kn9!ep;jgAyNa?G6CSoz!1b2>^*0*`~>AnUe{B3>BzvZ%1XD z@L$EVPu3St47{=#|NBb+%$p3?;K2udM*DK|akTI129%S3|8xHb+S2izQb&u^&DU&-v!1I`uyb}^!KqGZOh!DrBHmf;@-C1h&pQ` z;Dm^3vL~K^PQ##XA0M0$+9m2SzY$)0`a=|>Ecarc*WJ#Ay&@`1JX3e(fM0M>E*n}^ za@n|fyI-$il5@cres%l&25^fSR}yZcJcG1nlZCiHLJ z7Wg#{%T?*JX$aAR3K1oJUp-Unce1YWgmakS1~)#SNZSo|NA=J}%G%d_i5EObSRZ*p ze4)(^nbBaYsz7YU>uIfvFxMiQf>6_6EWb$jye>g66o|wBjD{s1xE{hmkUyBz$Odkt zwE+0ss8!xnqfzEYfR@1V0+cye{@MAt(188w&9-xTHR_POUj2JH0g!W8;9Y+zVFwY-hU{btbo#wdijOrHt`k08w(BNsy9cMo8bP0B z;S_ulK=`uc`x2wBY-&EoB#w49iSFw!r)GS#>j?d6(@EU0N^Azqp}Co6&(l+X2eDcR zk=uX+&dg(yf>h&<-`q>gRUYyQOT}4>7`Hze~6>J}j+JX-O2Ewkjkj#as>-Jw5rc zw~``02lVj@HIcHZ1+IMlP{OtG%J0($JM#@~H^Ia=9U0C=XNF@Fcq7#vI2Gx_8&?Uu z=r;1kJQo(1;b3tY$l^>cEN-)d#cgI;+~1s^XmYSP6U*Xs&Rw!9$fU4_)YZ z=)w+7W@*6zJ21Qyf#IEb*Ke6JS><4O{~UkF1}s=$c%KfK2n_Edf#DS#py1+}P8a9H zHo#w8_Sn}+jc{>7E&=hK<~QB=(>7}w{jwk`^rTB(99ZM^6hqW_ zndqhZ4a^K-OqC}(6l-a3O(m$jm>bz z&J%Jr1o=ata|%pFz97f&_N95qNAne!emwSY+n#1kn6MrX;iU1yazfO7fSnpLatb6Ej}&3xNR5iID^r&)UOLTqn-|7_Y=Uv4#pTrG?NdS ze87&*I8?eX{3PR*?hOB-Y&M7;pmr%R?UwaCBLtV{PM>yC z&en|p1Hs>m;3b|HUZQn&>9g<>_qqj&-bm`{$p!aaNbpiL6JRa4D-v1L#8B>{UIyhZ z42wmcVlUN7Nnl~EN$jb_m-z@QWt8`^Ml}J z7BOa$fssa`Ai258FSdsAdBa8kqOH0Wx*kutwX@jS)EWe<-4LJ)h8XQj^ybt+5P<8{ zt(H_zoFJ$r4}OPGAC;V)4l#zbtl0g}uxyVP@#kL{_*rpW%=iwKmXK(7?2M)HKt0d; zuj_dX+*^o=>DWWH>>i5oGJkkIr^8MP=XdxA9mJ618Wy&EgoqQ2zvgKvu09YQmU_`%;FLGPFN z!2^YRi@)dfEaOpVGa81qU)nC};?4thC!8k`m#wZxhheX&AaZFy!ttM0j5%wnWjC!p2A|r$ zfJXT6KRX`RO`*~rw_(KJI$J{lp@NBnJYoLcLs74eg?~hE_0>NJhtwjQpRncxY+zDmy+ZVbvG$pCF@vk%5Fx5Nm(YnA7ZIjg>m(JCP- zSMyv-g97rf;&BQ7l-V$oW1!FoS-&2AlMVL~W8HE%M&2Bf_zcI1L4pi~d-7o-<`n@q zcA-#kQ*1U0P9`_E1$fg)P52TWRnW+;(>9!g+7VBH29R1~{sPs4axdN9~F_@EEv-k_+mEk7kq#Ze+ zENlj6;=W!#`O6AhGvg;K#5|FG*_nQk#E z`lLhUH3H=~ie*ia*Db{aMbh*K4B@iPc66O`n2CX|Q+b!z?+5N%w^DM6oBSpCLOZxc zkaQwCAnaz>nM0(mfSIC#y&Dv4=UKmYT@3E6xn5=#%Ua7LoZuFI%{pa!H=g%dkj=?y ziumb*552}NTUKO~7ptj=^2(-r%D)RK(Eu_`PUieDGOoO>dM_OFwrU+&^NF;$&kBnd zSdFI5nYYL^FPrBgCnO`FFUBXpQQp)k^9$zX&7Ph<6+eofnroT|G$p3Ig8AuFNr_j&rUwYn!CqEj%lOG`giEA&P+nvle5M#jisBKU`9V76X6CRl% znb&8#t#_+CkB+#fI%liMdg0nrH3crtY^_h&fv#d5VR1iWe8YIhoAzsgo47r07-fY6 zuEul2T!S6DyfEeO3MV&=c)dD5;d<8uhn|IBK_J142&0ohBs@MWk50PD=;X5KUJCEy zxDOlc?>V{rL?5s7*(@XYb_%bpxoh;L4s#EszeG)`Mm43>AF_z+jT!I3{wVAdqAx*M z?R@Xk%Q*xNm^g~k!mB7p`@yl`{~&zTS)OxB%H!JZ=->SuL)sJgHPY!gdGlevftk91 z0N)=P-yh~66b>bSK>q>9?tC8oG9`1&E|31qBJ3$=(0?#HbKh*%&=OMLj{cY`=?fP= zSpPVDOyzm@h3CxwBi9#F1R+pWT)Rp-D=fIb?A229qE&KnY(6-94EG~ zwBLZ=tzEnsc-h_bo$DdkW4Fn5{vS1WoKr_4pM<$HrjCbA5F0^rh|D3n-Ygb*nVq?l zpF@OU+0m_813?woY_R5AQ%MT+A1tvbM)ToVt}9d5Hf9DxpJ*S5@`K+8S~TDbCBEE2 znH94|oSmMW%gg-V$|329hw6@})9+ixDJkwuRs&$+B8c6?zFQ>S6YM9|5!4oelgjMv z_qo4Y-J!g#JBGRRKamrW*~x1!d>>K;5Hy)S&}HvFhw~HvOdLgxg;$Z|$qSA#F4S>N zZtG|`jq2;U_HUQ(sm*nI+Z`J}1@~gNqTGWC8I)^Jt>*hrfB=C@m9V^GO>Ws4NsR=dQR{@%^qT0Naqv-Qk%{u#fZo{Q&82-tJ>ae|J=qn<0H2 z^Pkbzq!dD{eukwDnYZ*Ab^CP?oO}5l=o;7MLl~e|)wA6o%T-C!@Lm;_m@omnKIA=u z+)Nxrp+hBvIqZ}hA-AJ<;1&qAr2Ul@Af?n0ucb(+@*yS%zx#i}ZQ_-k>;gU#AWsJQF|WW{t?@Ch9}ha6uo6FA*#U8*fQ~nN239 zI+XZ7fNz}B`S|y$aKJUn>_Nyko}GDVw#YXgMV`}zKY(>g7Jgz-7QerbsT1$y(zp&2 zjmtUzik zf+t9xoDHT;V@=a%MkV@aO`MC@TD&{o4{kKZzPIOd}_M?JmRFh-TJ0rk?b^ zHVA1wjF}(JW&zj1lhG*ujN$unTZ47BgcZ>9`0OM3dl7#FV!s7FaSR+%_y1?CS!Bx_ z2-#6UR3_DbL>cL{cX_*4QWuE#!z8iYbn@jK)*qop#7bR&J5aYy-3Og=HDgMYy-@+H{>y#8Ug5^~hJGs4dBn9L$Piun6q^TU{|dJ~+qvItk?!-F`LN$yL!EwU z_iE>Uqb2v?b)`5s7VKlf**V>#|8JXD@Avg^t34b{=XO_YjK?c(0!aUTdZ ze@khUWvWM-fi?m=u(mYiikmN?4D7cNM2#czCz4Y0bm`MQ_sA=5GDOtBMVriN7l=Mm=W20jI)}${Nm#)%pHTbv z2>Vl46+|HUy#XD{Qkf#1%dWAiBlg<89%J?YYhNWJ<(8i*>V1Mg$7v(i<&)A!M1U|L zK+w@U!jf&EHkQ$v`_m!_BZ?2RdFj|JW$>1PF_S)_WVMr1LuAG}TN=qJD|@tO6DD%C zr320;eK&^0pama8l~I|tnsU(LH22j|IeecO^k)GlD&k8;oQC*%?MVR=DgNl zX)>4*)-w?1JXr|*V;jq(wUFfUQX1VD>I;M|+*`2n*iluZlon>eS8*{yHldIM^ZAii zS*%{EIV}SJj1X1P>{?h3DRI7#MP9o>vjG@j6fbUMAWs$39YE#XcXp>pL^bs3bRfPv ztT|H26vkx{%tg(FSL-?fZhF!KdlE5mk^gj8-Hy7@sE@h550t7~c(gh23n6xbR*T$a zbvq}mh_7!Nay1EP>C#M&@;so&@p&EiC?lUtdfi%+&^J*Ua9Jz{TrM~RF4{h}dovn> zqkd2neba@Gdyz#G%ZcuUBS0aQ=N8)60se#Jj1(NxuP|=ZR05{idejVwc_sZ>^SKg@ z^0KPX4D;B;QPk~?-{nDk>`Y9V5^-% zMH_NqwpPX)si}KS{)}<2nk^h$#2NYVQ^WcaWtXu2grq&T91`~AajXai`GV=#-mcw zhPeQUBulfYFa3iSJ_MgZLolO{q;+<{75UqP0X3uxG9<{A>XBx67$qbZ^TTb4WD&j` zYo{ECsH6GGRH6werdYba$_UbBJYoz#jMc`E#&_!*03B%8hRDOkSWz^2o)q#tXkP%n zCd>j3)DPb<`;Ab|9R>fPl!NCJID|I~c{%)ZLhHS02f{gp)}Q&lb?Zqvp-$eIl9LW} zxyocseGp=$YCu~P6XPv|*Y-Ix2xszW&93A8xEI6v4PmB{d`m4Kwp%FQYlrb#eQ1ncpo9u>l2AA~l|{L}U^qXt9{5-%S%ok!#5_;)av`;|O3*v> zeFV=^#!A7%CPpyRp46cDtA|mjL;TbW{Gg|=%>G0_7f7+}+7sgTt=ZjlL6cTV zftGLq0V#i~g z&T1-|mdkh6S|jzh!Y*eol+>2MxY4RZ9QQQ;!zT3>A#u<6%&q5@G0}WSEziA&bQDl6 z#&H|q*Rrh+81;K_)Ky10ZY}?7u2)=@5pEk!m5k#Ch*kjyD*9TBmk; zY1cwI2oHcj^LdX{sNX?@++FGU51Vzx`|9D!$We1B?&))#dYGqGsT2p-*=R`;}GLucYyZ@C;pH5PGvt zg8bT?W!ht5CmCB%pD=M0g&=qlj}i#Sy#I>n0*6#K{Br{+Liwsi^PqGa(DMK-;!H#u zj+-g10VK3T@K*;#A1FgSh@V#0CmWuD)2Ayk3ZD9V1mW!(hx8`1WnjxidhG!x zB{Y-tkSlgP03&_^lJWK`k+ij73^t*JjI@Sq;O7=4aD@^h!usMASglvwMl}DNtTG*Mg6B~u~^G0U* zY!*&R8z`P+7`b~CEI-)54qFrd>O5@|In6M5kLy}j$hH3DJZXXcHNDN+39Cx*k0HO{jg{-%>RD_yo3cnSXC}s;9e}|_6Gu_K;eI4f&10O! z-)_&`1iyvMYe5Ieh;SBhX3?J;39yG9CfxG`(@Uiz%J znPb3F2LS|}E5=a2ef}E-%XsE)^Iy$ZTcZt)KJZVK{ezph#z2Qp0mTCNQ~5SoV#Bh!vO-1jO;hQ;^qHql8!#!k zTqerJeVNs>@`aLvnl&ls6jm0@Dqqq^yu5*0azY=829u~w3o0?6ISysOeKF5puR~SX zOng3I=E3?=&<3?$jBB*s1laRnVzX@l--FU49Q^p_A#Zq+d{Wl6-?MWHs~B zPV4K$_<6>OUHA1IJE6L3bC!CqRs&an+a^PGdARMRIPta?9Zir;qW|mIOt?MyGjSBf z+lYJ&4#!K7p9qzw=E6Uz{O*v85$jVKK$ydCT>e*Adl5rQ=9=Y$tH1?Juxtl1t+P79 zklq8=5@mZB9P@3n#=s%99R5k$c3XZ-*m207BQ(_2&i9>b0@_J;j*eJ%MvRk2`qj9{ zk$ftob+Md2;C@nh-;$F4#W0V!oKFR|8~;okMd4mW=0L3UcWg@f-^uTEFqlFB$u{-O z9y^<>Q3?Bv&n);U`7?2@I@NW91WR+RVC1&vOJ1F!OZJuclIg)=!zI3C?A+V!^A6_& z;pUW}lA-T$a=7}u-MK;V#aA<%-17-M@WtrN7P%@=FQ_A|T0FMVHIJ0If! z-3vi60nR68X~Of6`_KRvOAHd)I!4d0Sn*YYNpSE($0ewfVdx;0EeOnLttQ2nn@|nO zU>pOE8;*tSIP!FtGb?5p*>$qC9+a*Ygx)A5-zTL?%eJ@d)yDZ(fnQElJS1#7sFZM- zF=T1`o!EuWFC}9WHsY2Oun~h!{tD4%|2c|@1g(Uk@ZaOs6N;IlEwb=y2*Gy`OE3*J&}&NtB(x{aar4qW}?gcpM*>4Evkt8xi`Fr^5o7@8Rc< zOZD;ZV;24Vn(P-L&o_$A|9aR8by~saw)`jLO6sWys522%)bnA${)|#jUSX#3IWguT z&S7x-i*lnc98x>rpW9pj>;~2lo(HUwIoVV4O?mUCenx?*a93m4hPO?HU!BTxIIL0>HzMLJ>> zX;{ifS5c0;wS`zQ*I`u|7|^PV0b+()HJKOAJO|NRCCCuzyZ|eJ%!{KBf)(JHidF!T z!zRu(uSDx1q|M)-UDZsu+@Ljp)nynPxwrT%&fl7xwv^0?!AeCe9O^jbD~~iNXn)E3 zl#>d3{$bV(^aJF2yxzm_XLoK7j828R;vRcg`}RP4Hc2cQQmHV zI-I7|cK9cqkMWWuE>|5@OzTSTFk8zdS4TMWv=E2zVbs4&0d};Z0`?I7j!z?O({|B8 zTf{XhhvOt_r6uyR5{~$`|JGW%o3<|;%O_g3YX2B!xVR#e3RDcWP|JPUn6o`Dvt?uI z4NXv6E!l|Kw;X`I7>GlKzaMx~alXf8O@-y$zpuyt9V=1bM{ z=c)5!nl3@w(} za8(E*eJ#X?6w3<|35o1^z-rP<{uLDz?iDYn{v*QrbyY&52|mQGjGe*BJI%h>|0d4m zm#~fydjs3hG*YxPe$CwJtY6@?ecC;Dv-4cu&%n=7Z@5>1LNWexli54mbhW|=|9xL! zd(-%oA{+PF#GqSF{Rr|SEj^+mtg8gGMDu>#I_0<+#{;0Kd(knZ%}yP?-FEDnDcD9W zBtXlJ?Fl9-`K`Fmcs_5s;sVyQKt~Gu#+E3VmvFwY-ktH=I?A^y>UdS$s3MF51Z~5S zNDMOZb~9|A0QJ{4s}I~zX^%yT;}dh{O|4_qX>QXPuqZLUZht2DzOD?Mbof{lc*OHr zO~2uCO9B?4Y4W4NM;qE_J(W&Ce|-KKqul)l&7?*o z?784J^Y6PhyLK+vsT6FYONZ8fscwF4I;&4bA5{})KDe~Rl&weB4ORwUaA}0=yl65M z7|NaoWlpVYV+{k80m(vvVw+om;?FlIL1>sbm!4|f%0G9Az!w^__93CqRAiMqH!lAn zYk~Gt>7NH#*O7^UgN|EQe9V>8#rvJWwruBmAr`zY@=~$hC_RdBGqJ+s1`S!8?Fe~( zWg__He3wDiV$0i;x&wZADrWwVdUMb@qjFvD%F!cV1SO~#ip+)AjDJoHsBg|*`=;GS zo=3WV-23`zp|73Huuc?pxg#WfEV%1IM?8$YsDyUw#;5mT@jEC6ZG)jA*A{IGW(ZFN zs(;NnSCB&|G+m(;$3N}Z#VOA5cg~lc&hv2|!uhL3`!@GjmFs+`d>bv5EwyQ)tu0>9 z>M>W-6^wZQn2apf^*ra_CFlH$>S+Ekt>)iu$^7g7lw|(xZe#vEAFH{8`NuqayYny9 zWB#?QEB>JM{A=%e?a#l^wb}VW?aaTdH*b6b^Ka0Kw&!0%c2Ils&(+rh+n;~=LFv!j z#r&&#!8xB`{^bX!E4qr~zw_9|$*tyJ-5TflF#l?T(iNM;`B#6e%5}bT{yij}f97;? z{#^sP7Q#$&#;^JPwSppCzTEOSnda0IyvDUSipqsoL9aT7>!_F9L$3loAB%WQDKKTt z%ptk31BFi(nr1G@A;m&|M-?A2%Mszia4WasK;*{Y@djTrRPt%3OodSCXJo6YF?^{D zye_!U-LFfk0ST8KpFU-L+7$6*E#zYgX|h1 z0^KAtSXkA2|Y#h`DH;V^TsnCg?K^fSG z*&f}3YhsuvuRZ{lf~v%Ybob!hF-j2GG!Qxoj#B)Hg)4=k+wxigt#MH3gKtDgN)wah zPwDN2`H0IN=1LvYd_Cg2>PbE>_|0L2^nH7M@+mv#LD=x^=!K=_GlmbRR^ z?`Sp4s2X@kLd*8#{WmW{I&929rqF2Ic;s`%V%B?PJXi!NAK=#AD}IeG5+R*luTl{) zMLiASRFpgi82gIP!Ph%;uDxULX0WM_`U9>w+!A+!8b-fx2!~Gl9heq!y_eNjZjSsr zqk9!Qif0%th$;J?os{pl*-n++i}fNVsF7f{3d_GYuB{nq2_+Qc_D%-y1YEZ?T%AE_yA;*w7-NyDstd zTdE6RYyo~YDCY!>+VTZaS>vz-5GvrARO@%$u!JJ(o&b{rxx=AR!XYh<9R}2ksQ_7Gu?gw&04|q=yxi`KY*j z9}m0HwK-XF(Ic`7`zA9y4L~vdQs!=~^!^Z%qxe@cD4v+WjLZ-YD=v%eA6(F;R~p*Nqd-xVuq|^I^Y5e>sVMnO&h&@z5A@C zM>KvOSYj?+jIaQu$k zl`p~+5C&&q)X(EGeE_8Jt~nOQB^+pg2XOgS&mugQ-~tPxQpfLHF;VvH?7|-9LGr)# zhPm{}+L{OH-pG_Y3*KFNv-|=VYwUSXLagkkaW(136cZqNZ+MUttZ+r|nL5~aVcQja zk9)Y2=!k_s6DQ%t9n0_aA%f%wIcJBMIRny_&#lW0`vA)@mmurH)oF8IrGpB_4q+kx z?!fv0K>v;Tsv46AlC|YM5hg&coeZy{zYl#cydJ<1*XJP6A>8~cx3L4_miUJ%2Vyxe zp`aKtA*6tt$>sBSGEEW*vin9o;l;Mjh1cG~h? z{6P9-q|+`&P8q1fqw!})gp0Ul)SG5H`^$O?4ygfhkN*0Sg6V=PpHqW! zr@%l>EJL8cn04El6w$kQU23AJN=afTf?m@&TfiF%%2B&Yl-^H(tcn!IL2HN#)S#DA zuVaqg4ZKLC7=(b z%!>oZ8uAIr_s8DquZ$VjMFk8(9|5w8>%L-O=sH`M_(A^#?~L7j28Iq&SN_Q^@(G=P zGwz)2o00j-c}J)17~H5})*2ltS>DCws5-RNp^9zXp!t;nrRE)DM+ug@=ETLEB6Ey6 zMfg5*{)K>2o0cJ=Km?kD{Ta7dG;5y6zd%YbkC4|O)iQv`2U=JG;W%ETyk$$Q5Iva z)B^P|HQ*yug34GoP5WBAJizmzUqcuJk+~?7LFQstga1vqrjXO(SCk4pVi*<67fZ#uZ!Y58v@?Tt5X4sU@Dek7xd<+jjQv z)p|PKBz3S!rV5)RC`YNDF}N>z{b&r+SM)4F#JZdx1xVpb}GsuhlM$YtV#TMyYrTb@ksq7K~LSyI}5~}63~Ahe(K#7jvASd zKc;L%=7O=uJ)iQL%TFlALYzCWh|6&CpgD{#9yI!iu;wlz4;t@J#aau(?!9)Euxq!s z(F1rp2HhB}54thr2&J-;uzFB9qe&@JPsrBlys|)M5YP7JciEC;%~6SUz55NV#=Ews z@cpiL<4Tg_vdSx<*p}squxnj7Fs;EUY~tMcCH|MpyK&$`^N9Tl^G-l$MMP~;piW=$Bq$>j=N}Fswl_9^(bafPrX}zo;L4C+y86?>ozL-QF&L(I38^A;H#JR$M4l z4%GR$Kp}NgqL1DeDRtIKd5v^MQeLCUVOP3zz-zR5HJ^&0{n`F25WH~q-{v(E*9I?_ z9Y)dnwRGa@Cq-T(Eg1)1W@4Nc_T{%9eF7k})v;XODpg-;vP&Fi$~e z(H5!O=R2~(bBZx*F!jisl-6g(zT*3#?kPB=zWLAY2f#$Y&LURcPD1}WI<0ZHxeb5y zxbdR|hqXa8vRpQ~IH&dZ3%+Gb0`GIawq7v5%=-lM>mJDbLz?#Cf_uB}89yQT$OWPx zE)~*%!EDHgBl6jgX3rXx>WSrmZyHb(yRVv4fGV*Qv?BWpez}8~x0a2A_eeHGKNi-r zEAxtb4blRrL23vYOsx_er8SpjT?4fLtS*|GIN&c2Tw%{QoGf@~2s5ZCk$6^&7}Tbx zg#D{a5~j1aweR(Uu?|75s$;N{t%t@~ML*58FTg{uk7>|f>M3~U#ixaQUvjGcWLJDz z$FM8La@DcxaNp?h30u|&SdMK%xLPbeaHNWMto1sUbd0cAEuXj(g4` zvEug_9tR89D4|Vt4dh0UrTc@zqfH}(o@dIi=d0n4DzXL2a0`S0KIK2L+|iQmAKHkr>p@Bgcg}cVy4F1w?eogDVNBSqu35Z0*_NCU$efG4@(I zMEfoMUT;JZ%U)BG{l2&a?lI&li0OY>oDPl@t% zSbFme5vRcGDLm%Nh11m&eAv@)Jx@E6M2n`(%rQ+%A2TbCU#{_Sq(V#H?ChMyDPywY z!1s{~$RLmXxQZWUem}OvMdK_(Y?F3ndsr-I4BO*5(iGeB1#d4kTKA|khRHvR3pYRE zsZ{I|u;E6e^Lw0#UU$P#Y%BM~Q0$Y$u-8aq*!$XuVV{j%-v9P76m^da66rTF6mOKf zV<-$Sro7?OO+^evd)I3}hW$o)Hs{w)4Ev!yEgwS+n=NTOhFv|4e!U$Gg{!aU34PrL zhJy1;f9Eb@*w$Rpa=?r>PL;0MD~^BW$wQAg$KN?$o^YNoqYXyCbj2w#hQ0V?q3e9n zCu4n58pCcHBgU|u*vcDH4ry+3nxZrt2mv7I6L(|ug`84j5xC}Io;_aHXJ+qlc*L(m zNY4hj#K*vS9g_HQscS_+)c4*fwR!yo^%|^G`+O(auoq7FR&H(ZYQyhvllN^n{SY?= zkuJUpeng?Jtq?DTay?`hD@&#-GCQ9QImGU2I1a)HDOA~2);APlP;g%4`5)0`FmC5N0L}qGe(bNCu$06C86Pc+u8E&$R}e&%88_y z`fJz|b=}})m`BGd<=xBHG_yU(uZ5uX4IyYf zka-z@b1I}frbP}jrOA6|(U2&Jp}K-$BYcS!&d`QFbXMaPbImJCzehE` zQ$w&p@5kT$;NKp=yU)~|ht}?4*w5g87>d7P4TKP0c|ZO(<$*uJQ`pJuf6p-d%j6Gu zXA?i!u2yplTm;)wJ@#j4k8*{a4+Q>FBji?p1p^8FJ9yu7zpz83{hQr~fC4b`_kAyn zm;!GmRDyy^QNhMb0el;;Cy(IUSeuM(JRWNqFuEoW+))(DsK>486?;{4xnqCXsE)2) z@@c~6V!bps;2}6ijG+yMW5E`h1BcW;Pa8n$N77CqtXE*7x&k1CTbq3Rhg+ml0x3_^ z6t#W`?`18R`eaT4&!V55<76fWa8ELrvqa-Z?PA>chumUt?>hayn5(oe;_}gHXNA4t^wCMzOl zW8crYZU*Hqf!ZtC@$mz)a|%p(GvgD9woC9^Qwru_#T7JK3lgUQ7^}_DbHWri4f!E} zWer%ELumF5sab}BQ|4sNfVbm-lOMm6B&)bqNgA;AxyHvN_-vRyf;OpLDZ-+PwCFfA zV3-Rx*yJ*GMB^LLg-YO8$eIpb`hvBClGV++eC4Pe+4Wo@AUhf(AmsN%)JF#8el}88 zp?x8!s24&9zMHaX$pucz3+|D}^*HpCxNdm;rfnaY%g4wd)Q?)`>|3GNZpTOV-zurl zca|*pw4Fr|i1%z1c+Xtp;I5NNeP^;~B)&84?68`Sd}mR@UVg><*JN9EQ{X~SD50N- zPU+F-qHQP6ciwkaJ4LkZ-krE}hUhy>BjY3WojEzdF>QdzH`mx$N!(%S|J1P|UNxy- zQy3dq2H;ntpXtD_hIta={y7AWc{!k;iGB2EkN!ZkK$|&d9S2FIiyF>!M{VK;s*iU>U<u<1lropozYGh)ZUbG2CpNs?xB}2)J+ndj}igH9zS}Kw6`@M;qXK)yLq44^+u1U_I z=%aI@XdB)KgAP5B)0VjT=Hfysd6yZqQbAl|b6F~4TLnO?n5g800)$@~cd8)FGbik| zE=uq&;eF7TL+&H`-Ao&SC=7jpP)V7;4-{GAeSmXX!MdETH=oa>k8*HgH9iVnA4xj? znCoYAW1cVJ5C?)89qfrilZuRWwFcajT4E>k50`o2{V*2@?`O?z-B@S8AF4plDe}Eb zF=-dOpn1fyW|XIREvF0>c29ncH4IFoAdC%NoOm-&l%c49<9)@Q)_E>`f!9JGyJ+L% zxo$Xj+vGSY&OHmh=VgoaJvgMkh6Z{1*N7s1M>q~cJD~Ku+0*8Lt}MtUcknshMF6!A zoPq_W1{0kIKPJ_uJarrqn%*Ifec%+Jc!u55d9qZI0it+R+@UqR!yjedZNT{eb%< zQlRAOo#NREa0~G44~yXe4?O$d1zDr-{yXvPXFBt-1p&XVhidES#uoAIZR6RUKl+@2 z=wWSlfM@@bg@6LVvtRXF+)s*U|JH9wKMy=Resni@_GzAY_V4^`{lIiRAmZ8oA(P&)ZX$qAEqJUbk_@a&)XiCW42e$@v(@$A}u;7B2O_U40*pMM9Q{r!Fo2NBPH z0Hr$`4K@Fi{p_bb{e%S1K6f~*>x2EyA9TmFJN(lA=|%AD&>9dDe+Zs^5CiDRW-kHH zUi4$^)d7HKUus`Cr8S=Y+lfuH0MCBCP{6ZO|L~d&c=poC8sL|c;MprXmw&Emg=atC z`B1()o*nL{M?5=!H^j4F#}(y{XV*Rzwgd6(2Shx(=4oxWV%xwXDV{y|bk+jEv)ek) zgxQODcIjGb0$fNtcy{wIg^>a7cy>Km#{|#rTtAMj#osFWtkw2w{LZfxp4~Rg@4SCz z&!WkIXFp&rfPQO@XNQM)uPfl$54hvmi$06GmC+HNz36;Y+BhE1Ue#H|vmcsr}HuMXZ;;W~*_Un4wuW$XI+^>HFNX>81f|lWO zBf6CmOaXIxv|vu(6^?qma}Rgf-a;V%lIb>a)Yf6bJ}=^^)i2#Wj(TIHh@-A~N`2iO zN4>k3fTJ$@DfThMQD0RGIO^JgK0gIIan#h%6*mF_M}1_Ch@<{=kL_dIH}5{lQDEup8$@!+3T-Q z-#w1{Qt#b`QXIAT{tj`}nPly{FqBf9bh2~3)?w(H`oY6?M^29a<@z-NM7!3=l5oL( zCfK3?^??Wp9{T3=3p?%t4=r5N8HaR>J4#aa^_SQ`6c26uMfa)SZ{eZsOT(7mF&_GA zZ}qRVJ06-Fw(9Xa!9&|;2mjK;0}p+65B14^6CQfkbo*;<;h~SY`Cddkv{kTBcw5%! zpZ-RP1P@I=9h?n#=;r$+KAbE6mg|i7Sj*M#rQ)(Be#r!Q6>Q~6_}OgFwJeQep)q+k z(W>7toh3DL+u7KpZaq?SlNh-|sUwNMey@OuuzoHgeGmi9_q+=O4L$#Q5A1n9gmQg` z6a($JC+HWXa7PSu<$G9Gw@v@Bh=FF734Rj#mXM__QZ;&Fpj#>&)Ip^S1I=zb@`4Lz zBF0yoyJu?*v~i>>zG7b%w$K@0;qf@&vk`aR-Mq2epuZ~&ba6NJgkAUEB?emibl5Xe z4748Rl<4#QpFG#bk!(b%-&>e#0?w*`)PXKi-1Cp=yOwtp3mr%Lg~w2J6w`@?^MrUA zhS8{jp6l~=VmklEbt^1H9fF-*`{9rLekkl+(s)f_H)*_PdDx}e8$f^W(gcpP5*(<-wN0~2yCA_05+3s8t`0>5v-mz=I>H|9|`$`am`sH zmFjO+5?u3wxBnY(&GzLGviKdi=3Vc2pt$c8*S!1ndI8t`uZc~0e+aJG*{0vdHGi|x z9oOvGR=kDZdP!{IUYOsoN0C?=Vg$vtP`s7rsOtdR?A&SFz%~;UyV4KA?H0f`@4ENw z#~-sc)p0j$GY{8820m`%k=EGeV!$>#{_^q1`TNG4fa}516k{YlWF?I@t7cTbN0_hk%*n-S&u?Bp*64lf<9u#7sIQ z;fKb9cY>LO>o_r!a}=#Gli&F@34sv_X7aiWW{M|f5*)5S`8hF@g-fxL10vqK*^zzl zBUC9m(BjaxE}!^34IFB?$X7CejHObh4|RSS1CraHaTseLV}T`A5lp+CdE*I)1~zvCxQU~)ak6s%{w{Zdfy9K< z+rdC4!g)g9JpqT*+`F+`{%8#3ZAl)%lIGKfCG+21x02e@x(JCaZC?>Kqa$0|9sAhg zcN^G8aUS!wv>{crrSEyH+-XbWT6Nc*TVo$xexEwxW1RCpYD{=5+a-^L@!)N2ZA1q) zwtx#I^`Hkj=cP3d=Vg^gAN+sBJKpB(^aMF3lMT<+FPC}WtKbhC92HS>Sim@HMy!Z; z$2j_IXsbR5^OO|hSR0W39PyV+{Np|wu~ZU}O# zJ&a@R__JT|7)SabOmPb)oxYK7%WE6s_^&N@jBylOz^^0fpqO{s0&}2!OxtufOxtvL zCSI;te@Bem0PcH4pz%O>a0@!|@g0HN;5;eB481J)2Os0CZ5#2HI0b;+a7Ge(^wW{Q z9?u^nqWSqxoCvmdX}G0tswu!wW>^NkVb2^kM08JRxsNG=VtNu9W)fojng8|ZJ3m|^;{y?tqYHHBPR$r zH#m0T-2SN&cc4Kr)@zvv0@x<;f-d08N`Q`kJLTUB z=hii}ehJ{*wz_a`(`EEG3rsT@4-p|xGMa+cRi#Rvw zS~8w(7w2XyDjXH)j&rLc>zLr&oa?8yRF)RlXRST4F~GkS&dnU?wYEFp+@=H0?X7d0Umf`}&Bytv7Nrw$nk^iwSS*6P1Lwb?i>U z+e-hUcJj7fgMGhE44os<4MR7>sUOrez#-KS6rwxFy#Mdh58Ql8pne3jTs&V{rjF}T+}I5;bvc_wOx+Db%NLd3aJdq0Qu9dd z!qQgUq`gZ-Zql+dg=5>}CM}7$?`Dz&Q`bC_UgVwF9G%-HH)&I{wzxE@8Sd_hsk>n? zUNHG5ELQxr^6oKpH!7*aMG|gO@%J(%xLypTTUQY1#K&?T{c@l9Pb>e87eoKSw zkjw7KAoYYzJzC*76cUZYvZFmNJNs&IPD!}zN=e(>wzV)`j5rU$@3I^YsegFbx3^V$ zveo*;58BAsyIV1Z>82vjG@tGQsWNWtSpCs#xq~3`*zx_*8iF9QlO0RyyZoErJG1^I zuoH@LWP4S6{8;xsCb-*fhaW59A*K2?HhH zoxVnXtm{^u9}9Od!jGkWHf+J|$B~`;p_3nL(=)#jNACPJ@?#Yg6Mn2=m96-(Ov}YM z^1#Q+{+KwjvrVx=&$rKyb-C10Ymo3`n;W_S9&c5y)kAwX{7hD={uEK2L~C7jxx}sy39P702g|4u9;UTvy&G zDqbWHQIOH%?;G^aywRCUV1)wxo51PTcHXFJ1E_W+Z&a%Oec)98ta+8&?LZD@;@Zd| zwYQr?%4}+-V!CojIq74W9y^bZh1YMDLweWO&#uXMUh!kHm_w?)FtAw2AuWo(FF(m6 zhqP`@>&7~BNV{%8>4G_=(hhpBk4FyavlNa;x|1&&^FHwp_Z)mK!6$}rE$VgnC!Ke{ zRl|04hn`O?L?D&ruL*VKtyctDZu(j9?+8>-&i6w79pOD#0Ur{Q*-GS!$cSPzAAYYc z2=AdQy{6_Fj%s!kKMRnBnHr9!*#s=2LMW8}(P!s32H%#58c{p>Yrv-eS2)Wa^}%#F>%AQ>zc4s%I9x||HZ}?n&gGPN^@Td+7%pk z0-|ZAqos~%%apSS?KNfr8n($k2x#=tt`6rYWubO6gduXhf`G{Vtq5`3u)iKSqsvTt ztR;T5=u>IArF~J+^=ZO-1V5vH3LM@i-_F+tv2m3}<%&^!FaNYD&?Cl|#xE@$@-Z7MVw6cH&Lt<9%(gv(ReYj(4Xq8wEPj<2?I0z2Xc+R3K3k!Hsi6h( zDn(4s34}Q5eW<3SeJQLDCbQ%9;lFm;xoJ7sx1pUtssxp3L-G0y@KeF?1RX6E@r z$yO-nPLlV9@IFHF{tz^x%#Q7OKd-V%i$#dAh;rP^UaJ&oH8kAc1dYHTQ3#`VuK7!w z(fjSW=Ih9se*-@ML)W|;j`cU!y!{se+9a(Jaj1r#OTb^@1pHNutDjlRQr%9J8n6J4 z-E=>U?ZFW>)dr>3_oZCmxWh^jP3e|drRLDTC8xy?ub%&bIxk}53#sS2v3i+>@#*AW zrWO5A?63A{uavL+6`%B%8I#mdc%m#?tX;IxNC}+q?62zH#nUz#xg8Xn6<)h(mW?s) zRkMYIi#TN&-PU@EfxaaCreC)$;mDK%aRwV{Qfv<$%+$ZYlJ9A$`6l@pkYBv+0fMG! zh!P$cl#+m#a*v@vsl_5XMYlp1E?{K|3MwK#ZnliEQ(iu-|7wj;6mzFrQOu?d%0V3J zF2dTJ1&8F%#6fHaj>K3nexJRJ-xCspgz@5IbN27m5xij2D6&zo?Ni4cGH!$}5SaHr zAJKH$R-YB}tx$1%XrE2rvX^$R*n7`5bzH>y%Gw*Ear^c7L7!;B5dPc?%5seG%J1f@ zuFt{W5#B3PpPk<#ZVS+P=lC0DPRoHo;d+{v4LI}Tr9|fbza=1LMGz2@+30xwncQpC z44P<{~$lzvd&H+^Om1l#hVdA6a&Plw7*NuO%- zw=CIKES1Qz_Ky*b+d1Y1zMsAz5}xezl>gCEgGt%}v7sP=BWcC+jpo?wWeAsqJxk=!7kN6w5#aq2#$}=+^3Oikr;9ut zzkTl2J2`rA=`_F%e5oR78edSK4vUMnXrW2gcVa6I>c4h+uxs`J5<4 z%CGdk=8$j)-4DZwvwG=wUfN7O1o>7Fs&XCY|Lf8 zmxn}Fs3=%091{_07P9w^!@U-C+bBrbug9l-V!2W|k}XvE)~*SULVc0lcIdr;vFk&T zWm|0bv4wC*{!AQ2MZ!_r?FNRaL*IkeEb6_lCG&k&U9(~#U#hL>`_Op{lx3ve9Vy)w z8g(O)1Bow#!h4H$I_7EFbE9A$v^kB3aD}?0rox zNPn*4=L%Mqdga6UF%vFli+0+`3k$uig|r4lJrp^F-&N;q7DlMxO6m#?C|=k`>Aot; zELR(yZ4-LO%D(~*FOt#7zmNLY;sASnctlbeOoSQOlns|Fl+z-tT=R$XxiLGk&&E(M z>FCBFxfQEO>sE~QQRi-4KD4w~&X^q!l&Ui#HdHoIu;Ffh8onO$6m`bzQvyvb&e;kD z_p;%$%K_diY!UG>s5@w$zgUq!&BqES9L=fnm*J3#W9l}S9)!$*^=%(e1SQ15Ea*`G&i8I7y`tbYldpDB~szNE@8lyJU9 z6BRw3`rY=&qIalXKm5>qiYrsf{m(@Q0U`T7fT!1_?ir>0rK;c1IdS`552CjF&@lfs zG`+evAGDW?N?4z!z8MX{p;6sL`r4Y%SDDa)ui`WV=O>0n;-~dkOZDCt)EB%)O`thF zR@kcXshtVR#C(O8%!feIcl?}{!LgVF?wqH*o<;LxkM*B;nwhhkf`J{2pHreg#=2GT z1qA&_I#{}I`V84n&Mp-SLtf3Jw^@)io&PxYr7 zAJ&(Sl2KWWX0DL3>0VwJMTU#xb;_{f0AlGnwj4GCfwLi>XzK_F zdit@e)APYMfkqxa8*s(C*^52lGpWrI>a6Q6woTtCdf=QIM^y8Kv-7`Ztz+sP@cdv` zF^psW*Kw;?*BgSC!nSTka%7Gvuy#MY>NLA~^)W+!SbeM=2%%LIHm_n^N_ZXM`sN`q zednX%X6wh;_ovfy4+e@*3d#=Q9l*gW7b zF~~;h-HUyf7$mlvaqCmb=K|ivDm+)nZqXki_&?PANH^$r@z!Hv(4U9%;!XcrAiuhV z$iP|=Y;brr*i~w zt_)tVsp#`7-F$U{SB^|qF8^v#3?<9nSE;OpA5WCM>9qyJlbP`2eD#6og_c6OCZT2M z16k(x15jQD>NAo$S|Z_$72*jTb9Z3tgvA zvx;5E$rbD#=8VQGd6+EeJiFNdl*4J`H8*YJf$NV(tMh*5pgs-cX_{i|^ef$Uff4bV z$=;0J+{ydDI)A5Cj?1d64F_y^QO12O{bRm^>dkR0DwO7lg@ZRm+l0Yv{)al->*-C= zxzl`NgMGG)3hn{RX_RC+r9IEeUdZrN+Q7u5WU|}kH)7{(3;VT8q&@CLz6o4m z*Mbv*Am?U&-01S4(L6=vM1{Y9A*|d*wd%+!e!*x;^I^q@uP{@&QL>(b_R;jJKL>9`FD-;Q2&47$h1I9Zgt?qFs+V)LlK`UEd{5Z(F27Tm_ zATMw8nDx+EJ-dZp&kNeC9mV9wpJ*!9mJd3^4alpaX8L*ol8Ai_)`v3sAJJB-Uvt$1 zrS{(6HLn5Dk^Q2a(q59w>!ufhdQ-k?zY^=A_HN0gruozvKR4z-(ThqAk->LO(4(m# zR&wNYSvmgnMRaY}Ml;I0Elu0$P0?(TQ%_ywQ^RdBQd2h-`Fvgb(2DqdAlY3a|=R!!1PZ0S9^J{8!~y4sz%?T@&xVL(jbL`C8t zY;m)nLzr|Ll;B&q=yAe4sI3?Uf>(3D!T)_~W0IVs_o(t}724CUBxmkA+c$$at6# znH{t=4KDRq!`WDW$QIR5SHirEd-|iz#Jwd0n`u;^F-rTahSWs?@=1;B?#qxWCbrp4 zVcJ=68s8!Mib)qvmp&v0|=I=>KIZP$Hgwj9=Ue($Z(yaxCYNMZZ7 zuvfb_q{N+YC}yJ%>z&H3H0T%Jd0q8Wq4o=ob4`vZyVSVxg8wCs`zuAM$-~d3ykQOP z?)m{)L!h;oJ72s$8pYRWG?ZJ8&LM4qE51*6Cs(ZNs_8jX^QR0-xj`Wh-{aq;ruO(- z*oFv(_7>|cx$9JiKraaqYK5ZT0evXpnmn|bcG7*RfG&}G2(Sp^Ixt5npfiZ1%0upesu#ptvv;;LMS{k zc*q8LdrD6o3pJnINnI_YbtnfbD_*s-*^h#;2xX{vV-ahUw!GCl2$o>l;Pr`Q3(%x` z8Q1p(TU&4!9DqFFDW7aP9CuB1nrNk#47}Rg-LHPh7VJ^!aOfh#q024nGw8+!$;5eU z6cqO;(}M9DI>5x=uoO#XtZu6Pp|De#_A&pgkbB)Mvp$ddsMCrPn@^b>4M%6_;X3F&sKy z8~=tn$C{qagBLhHEtwTF$PYfWt%%!{6SvX!)kl>@FTGRQ6wB(0`0e`LwOxHr$zVe& zP%`$WlQWaJ!igncqK-9qAL>~7m!%HyB&g<|q{VNOlnUcU%?ks=Cw-zcpRrOL)QQ!x@F4w{Rl!KK@^CcTvamLx;Ubf`Ps)}SNuP@gYq)vwt^$gaB zPP-5anp|xJ9MPTdNIi}UHp!2}sWE}*o!5BLn`SAk##5XUtyxgtF`ngSV_6G)BJ**c~hq6%+8sYHx*zn(%R~Rt`EvC$vf3#J9wgrh8}bxKOimA?kgw{ZBJZ(ChoIHX>Ne|Oe4z|+J{ zi65}gG;=}D6w~bNDY>N7fcFd2ydo!S{jn7>4Tt1CYzax)!omgoMv~ajvK%v%TI1X5go^T#DDz0>I8lq zOP`tlwWDrK1OF!85cH!(tvn3f=f!9;n$-txsI(`Ip{tcZJDF{YJ7EZ?ALe!A!G|;A zdMZu)o1yCy!RIVQGPCr|M_Xt}ScKYS4Z)Eg6%(7!`s`@~iQ(-|hUK1>^rBvqm9GF( z5e5qC@iYW;Ns8%agMotW<8b(9|8wwI77f+@_|1c{2w~Es{t%F<>AXyZ?|$13yd~D1 zdQGs*u8Ee}KG8B;BADa6u?3E^3tKv6G#;d#M8 z;igrC?c$>}hd+}htjx3w-S8sYh>t5PBVL5{1IkwOwNfxzh?_Drx;at#^Z0ICUwRka zFs#zJkpo?5wt}&9kF5Gx)iZaaHV)i>g;QV^PkVdkX$@#(Rc0z?-mvO-wyGOn*a9*K zwIuW~&3L=^w9$85U+SgDU5={sM|{-EqUVxCrP5gZV56I3pdq*1>u~I04fEE!-OoOL znyv6ZXK3n<`}v{)*~u`w_@c}X&=2N+UHi&OVT?e|ciD+HROBA!h!9D7=dp@hjbaZ2 zTWh6aCJXAR_bYU{l0>P+_2|Awq8AH&mU_`n4yqC>RM-J~%;?uyMx8&nw1mpml*m2; z(X|?dUE{}91LQrMQx*(Lot6zUQ^T1-o3&=A;W+~!JSeRF6>jq9_V0D8`1jr`gglqa z_rydY!Wrl14smh`PYiVRVgx5D{9#>T1|(D*JqbJ9<{9djEbJs>3u*=?&Y3Sp^6@&u zXM&9C1BcXh_$Q4cBTjhHJX8LZJdm2{hS7#pXZ;W;9pa8&0s!D>$N(RR32`p$lF&{; zre;JR*vVs;cD9RMdKlUuu1#$71gd1n<&xQ1*=6Ii%ElM^o)g@bE+0+wV8NjxBo+xe ziS0@99{gWky#EUd9%pIL9Jf8tup88~a7c>Is0Z<81MwygLLC)Dcx6Ga1;?(Z-)_uf zVUIW6_*gcus20MW7*{ktJ7EJ`5dG+4sTL0o%DeIWT(v2B(9S;D z)sMcZ&VOMe7)`uOv|)o8=HEn6DcMh|2FlfGr5oo2zLv}-CM3QXhiVhcY64$7tVv8v ze9-`&0enC5wZqwo{gY`ZqK;N<%xbs|@2x0&RJWZtjL{#WxemT&A64|9DfTSxrZ=3i zZs2KIh>kIW%CZm z>M^+6p#@Wu5a6{ReFvkU)>?CS!P`Pl433Ln4(ty&apHXpM}U&>>~~@qraW4`Uh8=6 z8waldTad^CfIM>(VYu2$8nNtCKL+b)trHVViVMypg<))}HVF6u&2a^8cv& z7J#Pe_W!eS7y|~3i!xN~48iakw-m2!V&FfL;x#X!iT-{e2)-658o5|Dx9#p<9>gE z=XX`&77Qjfdl)5)gvzO5z*C|lN2;O;w&&UVCc-G=>6)ODL20{Zj5eZs zY=yQP(e|4dBhYtUJNn-B7~9_cYx>TwGx+7(?ayYtAVG@>iS>@y*nL1H`S|-+x*v#& z&_4QNnmQ>a&GNM;PmInXE9{W)i=Ft{3>)mN=w~D0rTeF~7I@;GZ}RtT&+{?6&?8tK ziNw7IsE?u?>VCfDB|>0e`8=@-h7AG{On7O`Jeed&^!dmBMCUAqXdkJHSi42d_E`8EPbU=r^VvlkvbB+qJaud zlC^fTdq=)8t);-gf}C95RH^XoT27{W)kbw5&z(JcEq#O6otrw@>woe4wk`Z#cXYMa z-M=^S8nD-1Pp5m`{^F7QVXuomk16ur>wRI~=(_!zWmDMasqOZ8*Rp9>ITdc%X&!GG z+tKm~r)t_BhUOb~48-1)_eN{LcuDxD9Cov_hKTk-t7{7lsD zyec7yb-K$`_q-g;dzBXmk=V7bP-<7^4hw30tTbx~8`CFA-wVB=h_7JT-~Ht%xwiYB zhaQ{~EnT0u>6A?Zh7g;XSw1CNRy_+dCp?l~fo2Vu)v$ze3WVLWTiYaP0= zLJAQpXy7!@SoNO5#;uUP0j7!)DC=e77^aJ7t?K+)e;n=VS&x+E8Dl)pYF#}eS!wMR z&=w5rUJD?X_^e5c=Ufbe_x#>rr@&igWc$72U31{yxOHx-d{&1|V6VUTSfxdc722*$gCh3sntCt5oQJcs ziR}>BG{lsoGjo}0MpD&7CE?PBh-<*k{C8-_cr5fWU7NOg4j@dbl0f1!LV{8O+Ko6Fn6MlMRh*4V0?YSiEUK;?t9eG)3VVQCYDDMi5yo&2uPL{%U0GifZj+s)zy~tFd91Z}KevU>3d_E`O>KXJHKbZd+>W-%2a73@nlPaIcUk!*bA+ z`S=#Y`?~Zpg9DxtSRzR>$ZpRu)C578%G=#J`WB$3ZEb}Are9rXQ&w4 zLKDUmfR{hPp_M%Drv`3SqUOv~rT2;Lg7w%%;@z(=H)3be=xl#~%UGY8HE~yejqO=* z@u8C|mcqRXl@R7o_r%p#r<~Eq;}i1o&Y7Fw$MKPhsHkH3SqXRyw-36!zNo4EC(|lVwS*H(N&dwmId&Ag*QpQD+hUPa^HhBKPp!qaR9`9vcg7iAb67jq#6`c0UAwXh^4 zO0`RfnRcx4GXz;jAFEiFS{vSjw|y`Ls|-OuseRJ+!q&6|yr6`w={_i9UXn@Hx^Ro| z2cVXS9Vfy{E`{)iG%+F#4=H~*B+cEo_o&g!DvAJX z#M4HBZ<1=kt z`9?Gk?E#_3@&1;3eV(4{|76C~j?c2SQ{sBs$3-x@BqwvUC~b&%}xHLilKZ-WmZkfacQiIRd<0q&NIVkS&J6Tc#EM#JWAd7aN=o1}R)=!Zp}To_k7AF*KX zNm*QMTDWX>!Q$fF(!%-09)WuvT6X4vC@iYM{kI zc=>?uv)Ep^ro2thyZ(GKjD_k*p7pZf@R>K^??1L)Fc02#f=<`#8mt$|1sguym5=NI zGaVXskD0++l{+6(nrKXjLC>$1{!VzyBud(iNnD5LAHYU-Z&qHZ0d*(o=HZQp5k-nx z`5-e=tlw|r_pKoRcxi(R`&?KXBxy1?3zITveM}#~q7p2gNBx~92%uQ*# zM|U`sgHSac=t3B=b{??7>a`k0XY27I={xTS@rCy(OqLn)1T;Z*bx(1vNu(qExLgDu zcv1Uv_V3ms{{n!DR~+$J(g&jzVzyUV$DsgQqZf`MlyyY1ESgWjk5m1vx8AW?NOQdU zo$x)4@9#6c6Q6P2-OQ46W&^>23af&QVtH%~hHjeW=5?O{mnI3ysh`%`L?syG8TrNe z5J%Ypag;tg2el>1V<%nfDZoWJidMa$SZC~!nEEb+Vzd?ozM)7^*OnjhNM&r5x%!^Eyxi>Q1Lg-(qWtQ6&RONgCt~w8N`Kp)L4PDARDgU^(i5UKUmbKk z>FTe>Xz5eONYqD9spCG(9TEh-Z6`Rz@|8WUPhZ4Vl}M~9PF9tHSo0I;EJmLppfFtx zg?x641%k_Eu^^8pvOmhozV0DOctVMaS9fK@Tv8)pY66uQn~HWmY3TvEHG%|5KP$7Q zNw_-9qS45t2_Guu&dpjS>w@jpDgEeN{`fEOv-C+f!_QFuApER$dQ0Ao1O^=t&!JX_ z1l4T}HamJ8bV{xED8rS4if0KM$__uT+&2zXWQAVyHj45X2Wog=IAjdS^x<%^Br)3{ zND{^!U_<_^nv9mWyXQrXbPjZ;orbj1AfT5Vn+Iw~s)T6z5wC)frCHJVXD|f1Z2=W_ z%psVFZAFPswyVi#&R_L`VsJpU6QVPPBXz|Pe^K3JWPqWgd-&{y58x(FP$e+uz;e9% z!KijM8K>;Mdg8xSlW|{>`iV|!GJ5&&JC`fk$0rJM@joF~q#N4D|FoAYfL`E)pZ&h& zO&xNv&gp^@_8I!oT*s)V7vcd8B~vnoZWq;#bbi%+KolFXEp->(i06l2dX4wrbss(H zkH^PV_enY)1%kiR2VMmkVHEie{?AK36U(d}4DDWm*^L>X7yL8p$|d=c)hbo;|Q=MMxy2hleZsBqs?6Vtet$by`qnNd3o8x~%_*@#vkc z6Xd%Pi(Jz5nmqJSn>bz%BiB;9tLeBGY6wIFk&I%uTP*1Q4K2n?qFRxf-D9#mwIao_ zOdc7TMHPbC27lr;=n_|c-nhbqF%)+Trk{7PxEE#27_pA}idaXrEb0@b+y|zM^AHxs z%n97DfLya2crMw8m4#3Dor3T9u?NB{@eBLY6~X>zvg&Af z%lr&~UTb^Pn%qqnv~aIKg-0ZY061kH`Mp)V7bHvjJiHd{74GqwM(zPs4=lW(;_-CJ zTaQQT0poMa3u1eP$7f)hisQ{`x7JZG2f!H)r+M21;Jj=Vofpi;#q*;7j`tRkcyL3@g^W3QNdHCj zzMt2bN#W;}#7lVSGE4SN8?=e{%}rr({Ot4|HGHz7_8a$Aydu?e|5d*S_B+SY==MbzUcCN6?o1``Xrc4 zPZc6H%GwoQVb0>OV z=S;WfCkWVVH13e4W29b4;Z@X6P#++)Cg}QOEhVfxXe=V`VSUNg9cB9h5Pb~;jS8o? z3iUug|{LsC?d~e4d4`i98z(ul)J2A*o>wz@PYh+!Wn}O;DEZ+a9Y?fESXcxFF$7$_qu012 z;B<_KFcXaO|1$E=G)JD}lbfjVME4WVXBs}H(a7_rn?X+DWjLG+%Cm8@Qka#~UgiHs z4ldd}5wl02EoAQY{b%Nmm~TCNMVL3(8^~`T?K6THTso6GFs_Qwh=1&y*M+>RR&82a zYdy5q1nGWqN65RT_^5SiAI7FIvv~v#f|E)OHa~xHt@8_G!(YfqUkm_EsAA4`vK>g%5ce{3#Rk7MH_vRb}x;K zI!xlC2+0eLU^Qt)aZ%^rjnnN#Knry0ezjNrHfC-Wpi(h^RlTBugCy=~My_3FDW0jz z7yxM`U!f^+Uf?dsC-C{S7=HBAUhZw99BH_T^UMQ%IzJEG^!D@My5KzzV4d;Azr41g z)XB&FHQg)t{IwUlk0#nS=!;5G%q!9p@t$fw@5pcIxxsm2V^R7g@u9*zc~;DA_Kv-L z?`i+92__730_{Yc{rNzy+n1x7^mLfckyHgYHgOCy9PUf`yvP6GBL1;M(Dt98V^FLy z1xhHv|B3YjH!b@s`~KCTXx|4B`9!OHU^fw;^4T9C0UQEY7ClL2?Cd3z1{NQM`AmXV|wPT#7-pA6RNyqr9SX`x=%d*VH=VzlH2RGPj2KN?qEmm zU?UL8_&#fI@sjbsoGq4Z1$shsmvHEZz=M$;GYjF*t51LBcS@hs&JNr`7VWhTWbS4p zCAXD7-cI)@689?#_6@DiCh{pUQM*DJT^`OPFE=1h9AI0P^msSvs7-GN)IQzp+lj6C zYcC$397;pJY?)qCtJ}8hwjZt?$$~wK3zirrozHkC4|22y0M0wHyq-kDB)Il2U2SdD z!G(~G)0R0z36P^_L2x*)Ji8if%&bmxa(N#XjKVp_%Lx1MCGZtF*l-D!l;aY|&gE9C zR0PlYK>1YJSj`!RgGdBXne5@y>xgF?%VgId_6ZKe7!v?2evjC>|6U2HKRbOvs`VWL zaVLfr2rw(e$Ra_w507)nNFdGT9KebL;yZ%4F{VoMqf22;JO|+;+3BLz!&osHjXfA3KC) zvdM6~%Vb*)bx-O6WwNdA5Wnr;+mGv7?t*Q%=89neA3TI*vOS}}f8@Sh%C?B1e3@(- zk@sxpWwQCFW0`Ey+w;)d-B2bQo`(T@SSGt-wf#2!G43+iuy5O!$-XwNu8;&VVlWey z$u>60tIEh-B%U(au#hmn?aO4p*?l2DzZmJ*NttZEk60#~^sylg`*?hyWk_~?A)5Ia z8T?JR9ow*1v4A^vW}`Z;ZrKM(o6GeR;CuXM;vk+GUMXEhon4TniOn;i9slxjDgU=^ zo{$YS#w*_7uk4-G^*8b#&LHFV#4p*J(%~DPuKwSi2atZi1nAL4Xgmy?CD3!rI->Cd z!6+lLuK}S#A1fV8asmWz!=9^-Mx90y1GGdBxIj^rtD!xjZ!Yyl>=B4M>myNGF_N$W z61D*n5aMg9j&Gy!HMfm))hm@{Kw$XPuEdc|^&GpKwaQ#Lmz~K^)Mn!P)ru^AIu-|R@U~;V(5bza>YDtzmrT!$Y%ia`;3c1d<@%iEDmHA5Lv!76&vJ;>j{(`5BCv!W7`1X9@J;vbO zeO?al+S^xIVwX4w--~J2zwKN@O*b&His*hGwM%*80*J?5t7T&C_n!9qT3I=+$-n?Q zrAAs1B~@Q8Tg+u`&5LiHZwu}=7DCCS)%`X>EX+M%bGp8`bv9%lB$R@o%JG=rpWP|} zZj2jqWbMTYhkx1B3X2>9)4FdoMFm{zsUCX-0^UBI2|xR2sobQM*G-j*@yES=qkUmM zs7-^PzW}QT>-cM$dnlv`h4U#y0FBBa$Ci`eYYUX-*nZFHcfL|W88xNp60jLk&wTgv zZ5<3qVb6r=>f>j={14YNx4Dy)(3fw#)C2;qiDMWZpA3ALG|r*({Ib$LynT)DCnP`% z4vK`=k7Po57``gk^CLI!(6G@j2m2mdt%$yVL+Pu-*}iwd7B4>lhk8%Q8^ID^0{P1M zFi@Qu@b|^}iO`2{1RG!N&lGRk33y1Cd#`iedVUR${b2ooVn1BI@X0NJ{qT+m`(f5h zf`08&X7l!#ol}4jTk- znO*QFp069`*LRX$-*G}wyAaRit8|^+I6v;4?G7CBKd{1Xc#x9pL({M2LO%TgKA*np zIj4D{HhN|zy6^0&{nmJ$a!w`TMr7_;Y`@%Y1tJd=rmg1YA!1d?6On{`#2F zkWc@vJHP(*Bcr|Z>0@9m{%v~*GU!n(yqP`JRepB+v+H64o<*Bya%j?cn)?HWG>a>C zR8Fv@Nhw4Yx20PCrfuo-IcHNO3aHoDx?fZAHT`J(8T&WBMg=clHYC#cvr*%lb7}k; zy;i?Qe68Jm?ZxR0?rYugTJ7$exuQmhKScO#Nlo~V&=DAeiSyKEae4jbs{8)N@h~uEHWEE&yO#uiSx;QGa_Qq>8kz884=1wLV}!gZf|X3wgv*d156wP8R^(>p!MzM zFjJPD130-ng6M@-PDl{-*stwo(bzW;(McY$4;xBC;Q^yYjLNt+RphwfA`Hh0anu-OH4|{VH(o zj^q1*LiGM7T#|T5aAaPZFHAvKMFGC=-$~X3%!>gNtX*Z81#oc&&Pz&n%)1_kFupEb zD5Gsz*HShMPE{?|Z2M;V>O9QuN@A_XmN&;_$|QICLVSe^3m;zZ9v79W?H&Z%fneNi z`*=&N&#f8HYKxM5jdx+)90AMM30S`8)2C2e$b=o%7lQ8`5|r~}KQ9>GD!`p&%65!c z0VU$KcLx)Wi&a{?*i?jRKawdacSf3H$pz{Ws| z3+OX*%RM=Y0{=BaNcrdYG`s`Zz5eUO_l!}{AI2!$C}0hL`V8xR7H~b)iSdlhWtOad zzhanD1OnFCexx*y6?PL(AI+kb+@4GAF7&K+xK@yBsjZB?E^Iq0d3$VS%xr&u(N6e6 z1z|gc4p836{x1CXl#U>WfRyIOwrZKI)0II2z)|!!oSko4Bf_@QlXJz_LKL5?Xfsx* zM4Bm_0Ppe@0xoqz_yWNp?*(G58}4gd0VzJ58TM3K{@suhF7GV`z~|I^N#VK%HRk>- z#k?6FYq7`V7}$Xx^f#Z+F8N~WceR_ z)xT~~Zh=qd)+w!nj#WxNMWEl`r=QC;_e$3)bPi#>FOvS=OXw@^M~o%7&x}^r44b}& zx4J48pDi18?ky73i_5%dHd$!?y>v-BBRG56s+kSC0C5ia5}atG<1Oxd-Ho z$rO;G<{N09T2U*{m=+f6vt=iQ;e8Cp$Fa-sL|XU^aLujv)eJdb{Jge7&W1J~`&##> zb#L6@b4xcmRNI)iQA*azaiIlKtNREf&b-0*Y_B??V;d#4HonM8&E(p<{VI3GX_L4f zBkueJ;&Ea_`v-0xrq>P)N`hSb_|vl@|BTEO#I^cejwjMm+$44D@QmH;*@Mp31L@4_ zzAS78i!Yn-1p4{d?g}j8A+F(6L~A(h^rbbNoHHYDRW04ko)El-2W&6uhh`g2^i;fZ zKie=@$H08g(m)L;bm%R0GD^SL#({@@eBIsAJXtn0n>i77w>YKErecL&z&juC{(9XH zEIvZQTfS03kwmr+y!^QmfG5ug9r>~UxvwAqjoq*=3bOJG8XzmbtfxCGANHAvW0;$w znVFC7NQ1PDv@}5AMzmKmPcys2J*ckh1Mfjb6xl)OvD60&NS@9) z$XK(;{dgLU{f#w_WtxWl9h>3I{U``6l)HpWsL;|vDb25x(sV8Q2q%^=YE-0&C&%p= z9yc}yg_i|-BtR-9p28zYfY^&jfD%(!&GGB%D7Fsl)}(Nn-giN?bXp6BQ=LT%*2AkF zRY-GM2dFFF49jU7piX}yET=wBEt|fs@aY7pHddLw@7!COVFRD#Wa<_%uWs}g_`m#C zfK-v5hQJjJAKC-@7{wUxGK{Y&|_{yC4@?BgU zK$)lvWm2Sa5Ujc3>|+<2*5w6nYOwF#7rzO z=CvH*5}=;8#&NV#mVg8#6rd6cPw|bgF3&-@Ly=}&A>#7bY~+J}4gu-OBOgZQla@5{ zAtjfz^pUZev)2J}x8ft%h~^g(cKCz~>M*y}dN3G3d7ThDusSW~;XXl<4<3q2{qcl@ zDUzLh=)vS$q;7d=k{nud694(Y)H3)y#Yf^ep)o>gb?hjve8(_fdme|d-vS;O+iA}r(E1J zu&ga^>r@CM3^irkB`NSrR9@xe0AZ7(NLN!Rnx%Ku=C2sywVknE7LR3Z4RVW~t#|s? zM7J6@njJ$x^!xxtPuXa(=t*=MsMGK?Y-94z#4$_=yrcF9Z=I*_48msxdzdBe?Ny%q zJ@0$m#ot4eCxcW5>B&`rShyw1T1rp0QFtYT4{J*A0dBsk{q z+X~Gbrm;nt1`s^61OK6-KV7X__)ZSDlA-> zc(xfp>o`TY_Nxu{Pwim8szv0fh4(jc4D$}WhO@j*jb0S!!xpwuQmxb4!{W=sI4)7D@oOk$ zS~l_mUPm39_EFe(<7|%!6wPv2pkPAX@{3RS@zSqQyYHe74g=7y>lu9pN+ z(3=8wxc>TfxXx3Gkxmy(z**dQk_D`0tpzO8nDp#8JZ6+kIi@>qo97TG3qMZ;d@)u4 zz;2lILfAXEXPaB{)&eg!4Trt)W&d*!>XpAXV@F0>OY*2R3n6{Zznir()NLvUaLj=K z=2*j~?}*@~d2&q58!`-BHbKCGAcW^prGWJ|R@=Mry`3?;}Ws8Q3f0$jo^=93MZ)_>Hz!dU!y z0m!{j-^(Xq@RTH#P=dB*vSqSgQby90un{LfsL(|`IC+I0$_JImmgElQx5tZG$+>Y* z)s@z63VS_F*WkBADDCMy2=&$LfWan;<;QJWDhY1Wx}gf1UrKnzr)P5**l>KK;J{of znYiBB%ib$>(dj3DQC@rOW0>zB;FvN;kK8Fs(<}lD%|#2DC++1*-7e@xgs70v&slP3 zKO2I`_p}Fp$%D^Xa4G($fBn}bEEF3kEgAkiqRUGqmwJQnHA1w<|7U=jeYqq6>RD95 z(a7}kHU1bPx;K|Cmkiv7_m18({%ii;WSM{NUz2ZOH$l;{MdH51!u5mpH4c=(v8fN( z89oBwL3T;1bP_H$Kw)ei(qLtphp@VYIZ74^cHYQ7pbw4|G#K<{*-c>SL0Ru|iFTFN z0cXy{G0YHnrSu%>0&n+sVK@WxDg5zv{|96b`RbGrEP3cZQ!QyS^GyjZanlyk;Z4ZNJ{oVB#Q?i?s7OP&fx3yDOb5ce7rgallMXglmG$T3>-Q zjX!KVfw}uGhtIsra(?X!Z9+~-9pv#i2Sh%kQfO8yuX1){RJ>2HjQ}EbaP6qU8`Z-&WuOHfLw*r?b*`ezp8-q$yE*Wh_REug#?7CT! zb15R?yY7`Ron1B;W{Z){Su}(%oF_cIn16WP2^3ybMVdn37HfcN=81kEwl7R~RaOkY zH^}Cl@&0`&|NDa{n0T@WsqdvdP0D<$UhutOv~cc>mK^l#@cWj^G&Yr(j&V5x9b3IX z?V)4z{_U^LJS4tp=eNTi07wT@b88AMM+Ago8*86UQ*! z;NJ9kXdC7A$Ou+aMQx*V-Oq)yDOnj8-3b09+c*#rpoZlsFwb#2>SL{k;|1-({%K5i zAFbpD_f~lBeZTnL&XsWwcX@9dkYmlN$qLq&^qaRocw|eV-%`)Li^cc0tcrU>bZ`4Z zo_9ygV)QdPjWu0aG%pRnGpk4;^e{bN23Y&(kZKwqMCa!^& z<=~FY*L3H;Aa$W1;FPDJ7l=hs;UknBEc!X2sZs}9OmUFRVUVZJ3t?Fx= zo{73s1;znP$h>2#N#3(Q>dts8`3x=#71q>!qT3IpP2hhRvP<2Q_#aZQfVHdPZ-Gk` zTZ~PB*9U%3UrCF^Y)C_QwJ*o2)h^w06udXRe<%aOr+n;<*sG?lc?e4|$E8Hpbee)k3mu48c z*i+`}(Q$`MhAwfJxdNpl5&es|4>I|tc* z%I${BswH#F4*l{ZP)4wxDAMeW&)toTdoe@A?kGXLcrLfoqiGOf#&y^ zVp>x0{9P7Hw}rPp07e}E4t`{lZ1T3~51_7}bvg%2D(ybY!pOTPgoAw&?Umdd-zCwo zv@zWP-*;-mxICfC*ye5@EXL}a_W-`^M$T~$m}l;-g(93#g&k_GJLOH?0+?Dxl%;Df z=it7KrisaDK%6(wwNh87@g=2vPw6Baq?$UffdsP`!Jjcca<$JetYNGDl! z?5h{rf)sK|orJ+k*j9#%If_ZUq%3OXWdAa7NGGXAeR#_ijYC1?Ne%Nl>w;%=HeX`i zhwWg~z!%^@Ib!}}sf_!*5&2Ix@ahqa(i&6N?RAK6-4BPMZlQLiwjSuQiDMYb3%Z(r z5XXWUn=vn`WakJT9NXDH64VBY1Ka}74rlKn>mb-z(AS^|YLTcU+`?h$jFpq)f7cHY zBMYt%IwAS>agn&R2jKI~tPdn6c325dToI+^bUn84^WnBCU!w66OHmht;10p+Onr8g zpttkg@l+h_PXl>Fo&n7-JEySr2&NM2_DRhubvDR9Sm`^>kS_IvO}RBlQuw@5pdg zN>D~Q7*ZS-D2P{QgWlbj(p|0|L_Z-?&5Wy{NCr92+hBm<;9TPe*m68< zzQ*0*s}O4iS_MRbNCuV<*eSzm%RSDYxWH>UYP4l;&wItzlRX31#00mE{w%YuXG-OX z+r4S>movdBTs9i~@N<3MyohXTQ{SDDN`3Eb)vN4^bKEtsyyt{i8Np+zdEB+ZQ8v|D zD2}{vlu_h$N0}RWz2&)uao>U!8%m#EH)0)PW6UV-@mQbylBXJj7ixyrq0ZNc4#iqS z0M7Kpc&4ge@|jk`Rr{emrTQ=JDTB#5;`L_^-V5{#)6$vG;Ez8a0=^zVot7>xDaxN+ zly8Fk6cBI5cd(wcqiji?l>>(JL=nt7V!?T2e~3NhWq-t}>H?RlAM}yhcs#M4u0h!U z-G9}8$gjC^|A~F4LvKB2-=j-FUwK{P27N`@l=jubD_n$E?D(s`CjC`kkxIE|6`{&S zyuzcGKtFlC|R^ zGq>1H{y~>9{`4!bp0>PM-dlz;q#-E|WXNiiA#aI%S%t(9%eS0eNDMy)2Q)Ybg5iga zJ{&yucpW6~nbLtWIA$Eo!I-jExR?EH-&-IAUK@%e zE|0@Felj~BbIKcyu2w@I&;@1>&PuF# zLgSMIW~JE6}im?J#19apz&Jgm7>9*-p^FM?njP@-b*-k!ZqE19B84*@aWh=E_T zSFG!fV!TSu>)@EY7|xD$+c@_O_QXtd^kcaLTbBzC&DtKs9xdd+jAIY;UQK;1iMom< zB5M<4*a;C;S`!|ooV<;$V|n$1A78UL6JmhlAO={fcI3@m2f=6?jjC-^=Ii7smWcd> zt(j1*v@+(Yz+no7dWu(6qtWdlCe@CwVocMdZ4-2x;u5y?V{AQS2?ag-N^0iGZN`(F zT#DPR)BT1_g~mW59mLq*V&BQdLY?Q$Kf>a=Lkt859Unyiu2L0X=STn@Kzk4*5>e^q zQ!j+wx?ZyB0$;j0{tIbv8RstDoV7vuhiigY>1GWbj8s&**?^^+t4z9(xW{L%wPa_uePB`>300HQ*Nn)yC1) zxH|UD0cRCMCLH{_a}#0=!knPB5zkEfaru9lxPZwB=$n&#xg}e&qVLQSx#YNkOQpHL z>PP?)#{w=)+JUTI7O9Ez#F@9hSElTdTp`X}wSSl=&YZ?Fx#-F0NR4UsImrD`aawcu zKy1qPY+V`h3M8`jlfFGX*s^hCEWCZt2i`+n19P<#H6z@UUkf^j`)R^CBnl!B{zh~_ z>5U2|=<9WD%ZIVxCem-u=1YabX9Z+%-5p<+2yP?*DOo-&BK|IPiQB<{^Yv%Ox@NeL z4aA0C{V@ZcluzD1@?r&86-}Hc&%kzE98>Q|rTb^V1haep(0QTPhVMKH<}37MAFLxW zJiyh_QMPh@DfE-`p^w|MNL?XG%rUyqO*10Wq+)GkU8wEcm5r1Kv@a*#kL?G8c0yiR z{Zt`sKszFGG-gI%f2nS&e_Nnhp5I8xL?uAcy~ozu8{h<3LT>{q_1%o?5b=PvQ~W(W zFI_%!og{V^5D>hUUpLpd_Rnh8(~vQRFGhL5gHuw*pZ?-ArA^T^ZV>|*V`(EJ?@+N1 z&kD9Sp}AMPx|uOJ3y!5!HJiB@McWLsiHiW4gdEZ03D=DpV1)<*Q}XvCA+jT|spKrh zCp+tfPj*$nC!^!gzb{@l!*EzP)X7|n7L>sX^W&iF<{Bx`m$k_--*w{o_S(;^=J4jY zlsuWv=SlFit$;48S{9kgoH&a(FX?b!Dk~?#dqFRm4sV%4iML(?sq>`^^Yg)uG8;?& zEHM==&Yz72mdrxlLpuiZ=o5#{o;}Z0A~fgDpI2g92v-0K7Br?5cXT>GHZni={V&bWqzr#s=VeT{b zp!kfn45qa4_ZiJb%3JyVd3-=FkiGCR z!LLK|pj2P#WMvxIJ0{K}$J#Qy)cdd&fZV(!G2=H( z$i5HUJPna$dv2-V{PnNr5t6(OQ8P0mQ&CZ>I0(d{uGCWIgozOMjU6HG8&G3G7N+!@ z%@Sx)XY{*rV_rkSZi!Y4riopyQ39^WU}HF)1A*fj!u zpS`I(Wsf~rPwc^--02Qhp{p>mU#rX>hbAcfU_8}OXXWk!h+r!Z&^jI9Yq`n!p zSpG-(?D%*lwruf!6429`J{t@7p*#<18^7<`WBhgKo0r9n*s3QKESWGy+$X^%O?bY> zVvhs!A=-Zgoii?~&UhoNCpcE*tlRp@2v6r_Y@@zOIB#y+LX(wvyAi}ra6m0Vc#)9! zCIihA`2YQSr7$1vyfPt7mlxAOFh=?C>V~$TN#1k>BwN_{D95JN=$KKk4xYwx}dh}CD!}`E?$)PlF!nTTc_>ur$c$8MhM5M-^9(r0?qtIEx{-1Y94fJ*$ed>(D)5qE)8lOi9^HZOhec^uN#ObJ zBnQv)DP%?L<;j?BvAVgbrPZGCaYmXUX)O4C){CNezJVaw>@ECw@w~zQcH0ghpW0fj ziH-o41JC)2CR22Ljxf&EtF<`JUdx?3$vDjd@3q2fIJ;dL$nx=EG@c|8GGr@%fTRR@ zoJNzwI%J3+-DaCm?-Ww4{03d}NpbZ{g#XS;Zu@>$pR~i{Z)mEjC;X`Ln^@ z@aEOPQAt8WZP3;{`pgp+^&P8%44d$lnMr|I{-_tJZpv|B6-nW1CvLlSs zKf^}@-0UlRKVSNtKJ>4C_m5sr@8>lb*qlaki)%#jV2 z0?4)5s8&h)`;g=W>FfK;Ld$YyfKX6;p#Csdldr5Ww=|GE1#W&DWEEtT?NOWc#8_2{ zc2fJ~;xNlCZO&*x7Bf$}4#Bk$GA!E?4yvpx>YA2Wt%@&VK~Fw2rnjsyHT*sZ2P*-0 zlh01c-q_!#1xr4@a;FTlet8#K+>$u!RM|ZoKonz@T;&Us;?8m*^5FWoW3AJRf8Lm; z9A2BIMGKCF_>@kucl(`Nmv?p0YY)DyPKZ8J>%gM83>(@fwBO{oPq>=CQ^5rk>{~Z$ zgS{+OUS6oYSE6O7ex8w6HOvm9B_+?k!cT%*$gxJh(GG5*0Ccm%tHIwH3{W^atz|g44wbc9%?_ScFryFI9R_AdxhG0fWj_0Q*vkz8pCkk|_J@kRri8IM+0D8E!WJ{Yr+tlrKD{`0uU_1+S=7La8@7uY zZ2g5>*{7#w)in;(MmLL-0(ZNU_;!1e_!i&2*EX;@tgcat?FR){K&|-mYWThQb0z$qezs39$+E%q{S71e-B@YJ zh`r4_!O-@aO}Sa00iO12I{ytyaDS7%Qm6f7+JjlPw1l87uo<>ldfIn0Tgy^yhsn0v zC7XXW{n_l*X?Ik@7XWS4C@Wzm4bHY7PPMsGtT)>&wmw zntt>pb{tQz>Wl&0k-fIjmwd*LTT~Ae?75PF#b@D*tKu{LeHh&V--qE2aCp%JbvSKR zhl^J6QnuMOP(q20VeF;s>$pnpRlSsb&Na~4zhyjsHtHu%w@)x;uXDb3{@Xz-S|9tU zvQbKy0=MRTa4ZnMKAPx;zdE7xrHgq+VpjYte!CA>l>2v!aa_kc;VoJQ}PV56Y(!_x* z2(QF8v6)KDm?M&~K0`L7a70=U>!ZI!284xWHujx2Cj+vM)oEH?%;6wCBjZyosP6~E zgUCM<$1wN8yKvSu&L!M4e8FwJeRF|;!z$oIP$|#t(IAO=6G>tooB{{8?$ z1M>*tI>h7k^RgY>(_wyvdHpZXuV=hR4{J3iqv(8Idm_Y7GAhUl^NB@yxO;ya$g-mG zuD+r)+|9sZ@OU%fR&e(__F(A1_{cu0jAIiOm|Ojx=zdXt64M-9A5!G!{<*!_>f7b8 zKCNK-vP{{qM`^#;bH6jY(lpaC&Wg`T`8)W9D=nvSAB>o}-PjN}Hj&-UmO<12Kew4) zb9)<^TRv|ab$Rd&IR>IGbosCwzUJ)~qSpp}!^$>b1aYIP1yPM~q71aE0%aLl+6ToUS)` z^~g0$P?LD9fpPq4bo*v)i@`iB!qcFxme^1{pmNO4cYTis)Rc-^OhgcV&89Kc&5$ou zQiCq0DUorIw7=eR=Lex>jffMORiav^zFfN`0RtQ|fLb~B`9luj=w8QX%A58F!sn$( zy`C97EkS;Hm=Anzz#PNb*e$yxj1Q+Uf}T=!O|sl-R&`3Nso%vmMX;|YJ};ymCPMyFG~$L3mYVa~Nu4H3M0F1ZO9qKpo_Yj$C$f8i#8SO@tyQu+7N{`V zHgQbUuS4gEx0!PHQNPZdnFnV(gll8q6~|An4Zn%`Y%`2N=wLliBp}k@l{bt~#3m=@ zHOH<4nsm}$(V91|!fMmQHjm-Vz3=mj%^z2>ag#o&KJ&w<)5`kh;|9B3KFr5lYKz5G z{sk;rCHcOWlKyz?bZ8Hxc(xeh69?^rZ5rK>%&+k06(@RAK9LS~Y){_p!u;I%3-i#S zF$N)lp;(dj_SxCF6ZFLs#)A`p2EF^U$8-C82*T9&)eb&60@T$hCP;+`6G@Jv2{yBK zTI3LwVQn+}mIKmLsSNuxt`Gh*aSYQJUdcWa?DTp%OZ+)*6`@(ycdC?I(mx%y4nj{2GfUkhp(>VKnbgjL4 zxd4Pfg6uId-I+8HqojF+FTy55kxghdtUVaD6RTXxMI#h38qQ%=OKm9#olzaZ@COS% zE0V&K>qMU;Qo@s=^3$E$Jn2t$kp5(tG&aL$VRHB|H@>kR>L59{Mk+=C#2D18wxx_5 z{VeD{xT>J^Xjz84b=!%jIN5SbJv={*`bT&i5)VC~v?DX*Rq((4t^11GZ-`>6NkXi5}x8`2_*f$q!wo<7h zk5NvOG5a+I1^Z0$qY%2!Nf*i(=xLo9teFAue%O=#dFRYaQDR9r37%k0uIp~{mU~3V82!Gqde+6r>X4 zCt+$?MC%55Dkl@p+p!|PXZ#vaKeX*Bu^ws!J+#*xNSB=fUgyi-J9@1!`{W3}uk!jm zkXk$s1n1d}6hlt%W9csiM%<(NVK2fj+5yJKkzB{302G7 z<$DsXUNx5rB2fq1gT6ua4Ep+S(Kkf;#l;e(a-qk>v=vNDnI4nc zJEH<6{Y3i3pTpTbAa+obUEA!0ocb0N^`=Mu_SQf!DM9cV?$!T;@_M!*JNGUf6dCoF z*C%CT603)&bd=X`#_C69K$MwKmiq_gbpM z3i?&RCOJ1|qDM6hIZo?Zn74_nHxUYH02O}^#|_Ex5`Q6jHg1$NQEU_S#*&-Mcz6bc zHjwxb)WgI$im?0wKh+P1x1yZA4(u|iWZC?j`|@*3XP27hjLC*#1_`rMO}V+iY3B<` z$V2JJ*(LLf3Udqd7p1~aW}8Y&7lJMZ%Gc~6{4D_4NW6{$!hpR8ubyuY<6kKf!NFiJ zwVmWd=wM2DEMp+$bLEH}sFFI$=Ax+tQFZZr8x*7~oAh=BqF)lM$0T=l*G%W(wHs*s!Yj*@*+fBXQ0A+ob^^})E#Ghhe z_jMaYO1~UmHD{xdd!A7)M1oQ;HiZdtn)f>04s$_yyDz*KFyTviOn9qzUWgmJck94T zY*~4em?bb1z~hE+D{aiSnmfEOay5^ag~p%Zc1f)n+_hZ^8+~%YR*JEx4acoBf-6pn z-N|DqvRE%CZ59K%e8cT^|yf%olg z0f_m^%X9j8c*~%0-bI|B_x?*?g2Vv=wsT8LW>eIxF&MTcq7Nk$-=uQh_nQcCcSwnfMULxDRnG0@~+@r9~r^7On1VDW927 z-1W((IEo!)%s1WUH)msmV=JS)56`>fFV8yy%iQQpp#M>rdkm9i7Qx?5&3*b3B(W(_ z2QVK`f`?B&FVG6xLBX!oVgD=TXyrVtW%RxJoqp`B(%#$@>%ITiVcqfA3mHMKV|E3I zx`vp?siE_QnXR+HW4#@-Q}2sB5SiD)4SC#~^y)V#rTxA-X)2lZd47Bc&VmejMppTTEJr5x$P+wz8Bk`guRZTJ^aM0 z{=maCD?e8DqPEpoaxZWDqzX`o`FKTYAL3~Tnt&3L`k)Dj%#cpU#5PP@rycR}ANTn= z^RoIvOxZFKi@8>=S@zpAY+W)+pm=TKTUpMX%Xl5_V+E zb3Njuz9!C%H|UOU6w^v7v)t?}P?d^fH5e|Mz~=OX~O zcK8x3J1m|Xg>oAJnWa{NxoWG&T-6>84sLp9vrC|1smaMaSR0x8TYrA!h!A&A=@iA@ z=j~DnkJ4@Q=*&yA>Lom#qWV>bYoP(>3QS|LAJWBhRpIgH(KT%UD##hcUk9^ds2+!w zNv95HrJSFxfjC_T-ed_4LZrgJmK|YoAkn}G>%srfs=JsKOSYGx0jg?S0v{VtOF$n8 zv95Oh(k(6Fyz<~UG;`^NSPqK{5b5$uqL(}Y`(3Y^yKOMY9<2?SOnUpedvq<2KXlQH zDg{u{BHk@pWL>J=%TezGDCwkq z(NT#U10K^|VH0xpsWUbuK$NJ}2yRq9o%bHANp}S~##aF8YTUExDlqTWBczbn@lDM2 zb#UD|loEgJ-E>d<)?pwTR>ZvFx3HVFFl?$sYl}brVCrPkG{AZ#KCyQn;Tf_%8g$Db68|_tHE&r-Srd2%J=~rbWB`rb?J|q?2?;_?gNC3I!Rlg`oa01I2Ne%vxJQpFQIF#F!I%*=nTXAO$C||&fZ7jvyl&gFW4aq zP%4#`D$S;d-vIZohf3m*CY)7AE|T=5G1y#a*iIUQtqxCC3k{bx&w*Qb>MYroB}Kw# zw{QQPw`E)VvGBRQPC|7P@AztJF8^KFnCu^dkS@esv+)p5Z3D=7`brYmlSBW93P%0; zcxzX?S3dq)w-Tc8!Q2d_;hcG!i!5h%D;@<+7 zN2{#6hdqe_#%ncI-&tmrXB7ZS+KW4*c(@toEl`dl?&qr8gJpZMd`r^qM1+4=${kRL zXvCAdYk^T0Dq*YV8KxY&*FO%_i-gzI=BZL^y#%Z~B>$`aJMHZ9`TMl;CgaB1ebNuW zPS4|~F^Bvf>E_~^9NH_e(wLS1!r7Pf04@}z{qBJ>zo8{(ez~AL_t*s>#j`ccnO+#B zd+O{dIU-^Z7eY?n4jZ=4f_Nv{*_=X!jM*fc2w}y_%B{y2$;-@5U|tXPc@_h}|9DV2 z)uON#uKP`*jjd{Xkeg~zmBDl=eTK`;g<)Vcj}6*#`+><@Qlr*y62~>1<*0S&ET>`? zmc?l+dhTN&=mg5oY?~6Ni`w`{FI#Jfn`@WESua+!`T*)!fq#L2i%~2#+RJE=guTqj zTn@VG6IE=N0>xRn+31iyT3JxCe1g(?mk=W0So6mQIe-%cz{7gqS`(M*C7wbMwP3N- zK^%5Xoc(jLNozE?9#XUzjWAm7wr37cni>O9*|Cj2Sn8y2fBKvVL0bNauUNoCS|NmQh@FhXeLv#0qy1 z;XcEKFbS|`1f6RAaRh))oqn}JS^2kALju#}`AkE=V0N=}62z@-?$$PF6*%XfPt8ACM`8>$gdsx!tM+(W z**V(XZKYLauq7lJKK$^^PfAzF^_Ia2W{c&z8LUpHAV9heM9j+BE-OigfGC>*9ATKO7LR^lew_7=Bg(x2ed@Zu&_Dd+3!9NqnFg*Y8$PcC6 zi|*3C;HHn400{xQ13QvmVD6oUwJP8r_kfnG?6)9xCFLIj;eK7|I2~nJfxlCl>c%dM z0LU1~hpJbC`!~&$)EC8Y5(Iff#{f^ev(6)ux}eU>z<_99a~;U98$9ysX{dJFnga5j z|J(I~fEqveQ;}{k?3T^nCjbfqKYl8sQcX$lor+YQ`VKN`hie5HmGWwrP>zAWSG~Iy zAocI*g<65(JNe3fK3sy~Af+f< zFaR^ z>NE^|PD8a2;&L6A0j-2(Ti*E0=zzio3>?DMvl_0Tcb|2TXZ966(+A!IKX=E6c=DcH z^ZD%2a2mlWL>btG@4;q6>TB5u=#U-5?bIBrfq>t;AIe^r<_%*1Fr=$(X<6Vgo&WT9 z8d|XcHtA0=uN+)5@j<^BDsP}o3gs7f8IA90#YJk@=b1iux~bL-5xH*Y5q58^{-JE0 zD~i*j_1%0u1mv0fBVQSdRlQ6c!=QnT)_3rO_o93=zP5vr6~!jfJg_e3gJwBhZ|7A7N!Eq08bIex7?LX}eyuQM?YH4?K9DpOv?=DZ zaVKG$SYVrgt?T4vJca<92UbX9L)Hsf@!CTh4F1@#48VG3Z>yjjCAM3LHMrj zw9eIZHvvBzx-ab5K*<)W39WlE?45yH-3$rm!ZJn%nKa=;rQEq$i=>gPA0HdR$CBci z5kyK+Yzfsn1-d50l!WdO!ra6%BN`aQlud>KL;9Uqj{*&U&Hsr;smSI_N z!QrBSg6<-CP*InQ_e;Bg273mQVy1YjMai^GF|DlQg~ioS z(bmgJGE+1wOe;(>yO{syd1q!X2&85I?>XP!my>5_c4ud2-g)2W@_C-;^So8R#iiJ? zvL@RLO}Cl>exU$Ti^DQguz4RN$YD+DlD@$!0KFcPISSG1-X)Hv%__kfQQJ~BHL0!x zf=eJ}bG1l02|0hXKKF6{G@%PV*8K@xAjrY^d5-nq>K;P9{X@!w5d!ZRKa7`cQWLZS z#B>OD7#WJ0C=v;+)^~Srb7>_gF2_o-6w(7dZxxC}Oqf>XfJkIhAYq#R;V}@jyT|Xl zs26%UqJPk|JXqDoF?k5)H~`3yGvdgA=1Q}01>TodvLkx9dt-D?b`SZ)K6CxXyTC5X z5nufaGU2{4X@qn0vQxlUo9rECAhjFgh8+k?ETwXw^#*XIBRi<%^^`C}MV1N5`(m@w zmzK;(vu_(q@*uY4K@zuAg$y=I9Jaljm|2pX--$^#WaL{vz$`~LZy&u-=;#}b%gU=<~8_~Nk*A06dr+2soLFJ@aC zK2`9NZp9!z`U`N#+g-IMd_vE*p<;tw0(N_5$*A3)dbT={0q>NP3xWJR5sGDnSB9VW zzCu#jAz4%inlfUJSb1h~5p z%q*n98t?#kB%opT<@rb1prNJwbA6m#zrA)Kucw`}F4}u{IOpOENTn}7f-Q9vz4;lh z8Jsl1Yq4>aT(+S%4dWl){SX?ztT)wtWD!i1R@j@^;Dd%vaXd;l8M*0?;;22<9apN9 zkV{9n8C5pUHLIN{1d?nH?}lqzYv#|2232=4~xC z_Z#KV+)w1(+|T4*kppeGXNpz)7@ZLQiJC@#q445A2czw_p!pc!eNNa7}%sVu(}=yLxkAJ*!$vvagm8xgkxjakYOY; zqMedS$eFTdrcKGrn=~y0_xjAtPS44nIuY}QhmTUE4IPyhpF1itZAg4>O46vPv>{LB zU=s0=H1*J|k%?(TQj&mm7XGg{{vQyh*yAj=K7@1m%=YP*c#h2GyUSh{DEs$r{!HvU6%7P8~%DS{(zx zyS}s!NMsFka;kt_bV9sVw5@!H3rHsgO|xGRRtC2BIPuMe(Lh?P8hFX;<3dx;v89UK zByjzWpdJFgzw(p4uV5*nsp@Z_o9_j&t*_wsA-{F~Fv#ax`)o;#cnWy*8X0wr+rJ?8 zgni1B(e>tv!S`mnU@^GTGmnstn?5F0{JN=EoVyK5YrB<3n|2ybDi8WZ0SmyE5x23u zY{K^;zZVfWB+^=d)hZTcYY{rvE`zYEph)_i1_9yky$~zG0-AzeZHCTP3ib5oM+JN; zpS3J|H6UH_0jEbPKE3RFRaR4g-@GHEc(7ycNNt8&FQ+boA+|1pAx>QcUk*MG{L3;R zd^VgVT?7X>WtO#!@iP1@;^ZkcRj`*5VO@aFM)Eob+Sd!35Y%2_y^OWzJ37b6BNf?G zv-7gGIob0w6Jg0H(jMU|fh5VatYIS)(uNF!6$8rz7747X*-wt_3#$hf%Sct)kdcq$ zl0tr>-Wi#B+U%Uj#%-_Cl7^~DOn|4ZANgdOQ|{$gxI&CL&w(RH|3TP*InCv)M{;9D z;zVexgRhCh1h#tfD#x}EZ()0lE4S%Y`#f%u`*e(DjU5*LzYP>*<%7}+IDH_P5K%@=yM^xquKS8diOuOX3# zd=Clcr$rTg4J8SqKtW`YK8b8^t~DV8^}zPEPrb*l%6IW@&5ht~hH)+|XA^ zuR-&t8-$*W*)NOz!u7fOcD1gPO@WkqNoK%ukk1qrIR4sW{!VF;^h&>L^$R7n;;8^O z7K7HQ0IjnWj{(U4tEa60)=FncS6iMyVoUb$#S?PuyjenjZaqO{gmDtMf2T|i6MTn( zt+NpjD0b%W^qK@c2b^$(Y#X0Oww+JoR#(IIa%?&P?m6bI-yUC<7Q_ZwW}d$MGh6S8 ztrbJy&UKd#|Kdp>r720C8`smuJ#7?tM#@Pt75}!cBY$iLpRu@-h_Y6*nIXX1EIH~z|h%z3q^-Kn46s5 zu&>Eo-w?(}FqPs+{s>lk+;r@r*f4&>#+JCvI>EIHGTB+b2r}5R(4mK7!@R*rjtgcz zMWjCaNP8%nxUseQV_;8uL(kuM83VlgGMn!xe16|^f)BJZisJK=h<$-LKKE?mpMXuO zmmt6G=7pfdTY5HGDNP&aP>uIjO>->FNNbe$Cp>4tg7W2`bJM*W_k}^0$6i=>HFLb@ z&~0j0gZPpoMssn>pEA00rsICuK&ICT!DIa2tX8`r4d940aEMrf>IGBF|U>#jq3 z*GsFg_eP~R6%$@iOn+d3uo0v}?fo{rfv+Uih4l?HLL`ii41Bp1!d{-_`EdTIWBwBK zF>AI@q%i-Q=@SWNfTmb5XU}dtR10)=9OR=#=;)`e^%~L-QpNRy z92XD$AV<(O`y3LK-Wn#+uZDh*$$bl)`$1~CmWp-N*uYIIv-4>;p5uvy?>qEVygR;Z zyonqy$S!8FqwJ~>WLLwS>2}%W!9VN9$0jazJhv=$L!)zBoX%Y@oLe_{#Qo=Pd~Bjv zG>2=EsIk2GPAfmS1ajS&b0f$fv^+=kXSw_d8NA2I1`Ej@{~GomncPOlB(lktc<81($aJB9(pyvEKGAFDwU2M} zz3}3@bB78hl&u#Y50eUxHz{O=6)MmJP+e}WZs@8Af&{nVi(Zw-_dzcYVg-byTE`oq z@8FCGpKEQhC0RqWAbIF{FjFRt(GM?_O?<~WS2*!0cez!ujypJa3mhz^7_%(PwQsQK zwWCF(ZCrWu0H+RY*64vvbYMGsO#{n8qjBLXd2?$J%YLnGRJ(Yyk&x$9dWcMETg;u> zzjN&=P5s%S;C)Nvr2U#gvHl$_`HaE#Yq8Qw2;55@+OI7cjP2L1w36tmsAz$oV8+w+ zXRv;z0&*qBgX+9;3rYO0KjNUD^urQc2 z)o##gD7V_juT1Q!%cEpW9{5mD`v>uMC?p@@Hk*Ylw|~<{i8G&$Q!TO-<{H7|oz_&v zG=2@P)K_5tHB1P3Vqd_&G&p@Jt&F0&z^h<)VC<8hzujT;kNf@nVZWk3>i1(`i|DtK zwb()*9WGa!^Yi=IuGNr@*ShIHQxCVeY9TpUk=AeawCoJRu1=Em?S9jJ>zBUB`%BIC z<6)<{dpc`tSe9`|SJ{{4*71;isl!Fl!+$R6nzJ30`30^uj|NkNyQP+m_ikRV3$~JA zNi@b{M!>TWYBwD1Kg^-;WP4`JV0>l`@Q=vHX0e$^h{OPF2`EYyVlDPDuI24tp^pQE zRY-RLT1AEGo{g>iF!b(c&<>zT>N>J$d1prDLz?i3cB2xDi z{p(T3BDi=B>It-oifF(1z*Vthj6UJ{?W9{(G}0qOq1CY8zM6K{uxn)gu8~k~Wv_qf z3E$&&!x)^O6PlN|jq8${jzi4m;t*MnAP|v-k%-w4iO9My6yabO39$&ni+n7i_|L>5 zqS1Q9gjM28MteJQdq8sz_;5LV$Y-(g6RB}5Vi^fPsJU2#j_jO#9Aa7VUtsm6Ige4E z`b`cz{TD$r>oEG@3l11orOCGBf9M4vVl%@imlN_wx+XWU;noQgl_S2paKK|7MbPHA zGN=b+sl)>JgX~BvYpWT~%@vnD;|{HS6+#N+kyfYPs+*BeHmyuPdi`#+fAm!NOtL?z zeGHg3q8OGs&&4J#Zt)CPi!O_LS+S;Eq#H~k6!{-4BM}Od5TS_HK^Q`Jz^A{<-CiVzicy$w&-BRxl7_5b4q%WSEB?xwn9Z4=ZaOV-fL=u?Y54a~>Cq z2xU)?3Ma7$b|c0jZac&xRE=X1`BEWaG+%1V_oyAdWF^KTG$u6Bjy-fNLYPII{;SOu zViAa@3-;6?`@3s#{#>KJ{E<7ZLe_?Lv%s+wQd%-h#SPb7DW3mto|NZ|(&$SVZ@9<0o9G`!-cFfTH zg|osu)eMe*6C0{yHyI(V)$$e};B}Uh0^V;s{x@vA?hU=$g-hUGL13OmfeBn&O7Fvn zSy51l^u^)NRDNSH=(GwG^Gf`u`Md6x#sWJh*O&H{t|P|pW+cNg2;jE`P%Yz**z2x< zt(@+5nr%q_Sk19%*GFrN1meE}5dRK<`0Ehj*U+?;gZP!bGkAz!|Ea;#5#q1h?geh! zDOZ}WbE1cByIwIOU^MxGtuLMDf1sjwjuP4T_t2?U@jBY58?)3bfkdLgPP-ua+8IB|EA~yb%N4%OoRij1Ts~e!GEO z;ecLAZ3B2c+S36ox-m>bcdQYL2yS)NT{i-9@01i&Di$(-O2xJ^XT{FSy6t@W4goG8-Eqri2@NUgfaT7xK^a;}DpgY@5I%yCXMJG~#6 zxjae%WvdmJ#q}pOV;U1YDb;?D8~uae4qSpaoV*5pG2FoiZmya$UJiF~7Yg#aZK#Ye zt2V(eoQ4PV8{x2*ybY?-;8W!jOSO6v5j?lI&+z9ifpeSpd;IzgvlddgX8JjtEi_3& zci#(i*ic?v?y<{v09?&G^s-o57V3fBek<~+>fTJOVj|0+_-Yd86mYWme>&o1*6BRP ze`hW|^A9k73&Hr`g7ZHlR+I&}4-^*@7qfA|*kRoc;$*RXy?SqgI9ojSC$(ez!E3CV zVu-|!K;%)Ax_3iM7{A~H-gnRNfmTLQPr|(jIuPR;oZV;`3!7AyAS)jnFDLie$W?9{ zKA(;7`Cqjt0Y3*di2%CYPqdApU_0_-*ff6r5z3;DkT_K|Pdk%t%9(m?ZniIaV9e6!aOvrb)1Kq8T>rlFz@mV+dLG`-T2tV zOOEHBoVvHsx#QP4p4%v#d+R*2{oDw|3ivDM|9jwcfmnRD%_e|)OVzQkK*f*QD-&wyIE>!`*A>yryzvk?e~#_^fa}u7 z!v=j}$90X!wjvkMV*81_%e=IE*~@Cv0OQP&dpl})x86+)_pu6&Bb|I zSf9U#W`F27&EFU0a z;!v;dN@kSFABFArl_s7zoBZ|O0ya7l8ap>&IpTW%LH-%0k!xfx#?K$pE`MF=S|~R| z!rie?=bn+*tX=3)u?3riQe6I1I^;j~eyJ-tShVp2I2dc(i^iy)D5P>`Y&!p0$1|vV zmv@%J@5-TAqT?CGZ_8od4^%1agDPE)pw$VFIsG*dkzH3)hcKV*JjDh_YeyAUc&135FW2Ll zSV?WIXM!hp{KchkJcmdx85x}4FCp4QuDI%@3r<&TJpudoUGet*+d-?vwZCxUbFL&> ziL@}4@cs}t8>eZeug!i%8{iN28VD(r8t2cRJm6@c<%Y%{+2&aT9Gll3_fk+8) zAq1fVDIGXnw`CIQybHmp6~~oQ81zz)?Fc)66roZrR#OSEG|T&g!4(eAA_-CJ?N$#& zt=VqWGNh?%Qa1{ibTe|MSxg!cu%=~5mTirL4ACDATl59?2VXS>e$ z=U|iC_9yk`?7v-8{-G>u3g&jut@p{b%K`w`EY5A6?(XTVRX2XYj}`wr0aSE-=V$?C0q~eQ11s#ded_e7N3)9-H^_-!*F+# zb6v2Bn!^Rq_-PIo4~5V8IZ1HwpJ4wFaq&ln3Pho~lLYwLdrjPZ1h7iCaZX~usyDV82*t;>yLqp@L; zMCCJ4(WmI$-CA{tr9&lImYXT%chJ5>X*8~ie8llofVXp~@;%Wk_xSD_ft|lOsuL)2f z9?w;~YKAW<4z_9pzYHn_!pEnt%LH0McSB5@eC@^qq_ zm4TT$)Ykw9$_h00;sJ9;VQ=J=09>my3aj$XUbd=yh?4$+zU5~Thr^p@3OM{YSYv|C zhj;|P_SV8Cr3J^dW&PSB4&UsGi)m`b#XR~I2LJ_@4Iq^NB)18z1=C>3!GePY4aEgR zvAAGJ8rB_*eBz;t3!cW}0vIPd{$aA&-Dt;J!;VjTSUjKpJP?Qe!E^GL&!=bn2|Pa< z=8G?rLh2hN@OuxElaGm<{QM}vYaH}{^J79@_Oz*K6SO%wL(n*Mj0(W)fHAVq4FQzr z=ZGC=)PK{2F>qgSw5*OV8RjFYLU7rEvp5rczLQvI9$z5Rj5iHSJlnI@lTZ_D zj&`hxRSU?t3Tk4Ls8gAMm#Rpn=C!VtRAmWC;#bu`Fu-eB!%H#Dgg7xYH2|8aavde< z2A!%62f%@D%TkND1o%k>z4>Z_t;0VBoD0r29nsh8T`zot9(F4BZzC0Grd9v)3VuaT zen9`(Uf~CFUEHurKowN$I-RQ$P^<9bYBz9ANkVcF3`3Aje*p-vNda zqtS|;q7S?#E0SuRssv`)ssv^^RtaplZiQHb6`HM~gSI2J?(<-4P-xz1?_b!W6?Mr4 zMN&zKl)mnI$&)?>RRR{iO5pVg9zQp#68IJ}`QK7wCjWF@|E-v7dq%d^B|jnV>|4~% zLs%tn!Tim3zDi&r+`%n}JMe?NeoG}ZR_vPrRRUMBN$`x+;83@-Pkf7@kC=aw zTj$@LzXJf25#6AW;B71N89Smh$$(Xi>wIRe!7`QLw9+Vx^0gbv6-DAQd7zMBVdK!=K<^B(? zr>0}0E#sBRQ=*7hY`1TO_{)1({0bhYAcb3qzc9_^)87|=5loh9OmT4NpvcE%g!1*v z<47rETiWTjQv{F--Qbwy{BDo3m+-|EiWnvg{ZzG3sV&k)%PoMN#~9i zeJ~G>=Oai@6;^opcyd=fYh)j%E1oj}_8VVu zz<%kh(Gz1zfx{5@y$jMYYk%_7;pgOjz(hHeo~ox)!mhIx&tYrljVXmJ=A0z^n#gee_t!+K1Ym`z_HL*swcL}zuf)G`H&@nk| zd4&L%pF>Y7XFhjZ9I0v9{3qf_@7UxY#*xm3-K~3&IFc90GE&pl%ymFI3Si!vjHrqa z2c)Z4;k?-E|9#sWl!02AjnA6Ip)e-J%Sd9Ih1+DLfaj&9<;}{?$xO@1)Mh23Sh_!B zA~J7YZYFqXGxIXB;RKNXHwFQlLL}}3BxVm8lANvpu{SgYECR=#PIf(kem~I@EyS<3 z!aX_0I0POr%>BokTk70Ta1T2LaXY5v`iC`F}vQmPv4XZ;5r`{ zi}qer>7+D-wz~m@2XF}?|0-swz{EAi(wSiNcw>^*A~0dB#osBo5E!RBmK?wk*j|v_ zS7(?Dq0_S30xaIgAwcCLOcw+|r zf=a263V_3xS65-d2_Akh)gT1o%xQ-^V<+MUP#eZ)-c5vW4#i)*;r*7+NX1Lwefvnh zOx11J?01HjO0yc?w3Ior)iG@Zwz^Svwz}f&KA%7b4&cfgh4ge*8xapFO{JRhr);sh zX0XE-$UJ_W*lRAZ4K|LAe-P(#Z+MTJ%kh(7lUgLK-DdN8p^im}*EQ=AnTgZ;*cS<%-UJ6|TizeVE?9z+0$iL#K;Z=Zlm( zwn7D$N)pw#F3Ef#bT<>%`PY<*?o0JA-0fVXWFhBq9Vol-qqW}_z9`C6z9m6JL%kqah8z}c%(MF?NFZiT#5qWqwV z>tc2|`arr_i9H3M39n0)_G1_j=kxcCd6dq53MQlTfFA=kEZEw2U~V~B!?rfagkH1~ zinB-?FEXn4bm87$y2L4|7%6lDeI7{5i1AWBs>sKjdx$lV>MWS1?=Zk}r*eN@2CYbA zk5aNT5tJk(?s7`lFlpp1i8(jU8l?eaXP^p5GT8=5YccOrUH(waQoq9t1}JU_ux|#e ziap>%qfF4sD5^EQ;&Zq2xcwhjT*K_hX)VQ=&;Ioo^LI_a%CV2MJ}di=V$7fHH@*Mp zV$7$=JmTuJ9AeDPa>X63GkR@kBF5YU&coZ3V_@^IbH$}UQm(l42jhw}e8@=?-&21k zF8n=eum7;PurG-Vo8vF_IK{<<-xcD*lYYv-+HzdD=%>o7|3z_O$$v~-n4d*_TzIw+ z7fvK=jmrhZ#9n^Akov4Y$rbmgRtfU9r2qX~arHLe7k#=5Ve6lJ*jTRlVPm<~3r;=v zCt|r`u&W=oHfwt3tn1=(!iHD_!~C^!BXw#wrc@FQ997 z`}f_wk38Yd{RhW3F3@aT9nVES0DD*3+R1%N$`4*31>l?9sjggeU$Kj9OZ$=`0g(!9 zP&WF*kyo(laWr`RY`1oyD>9s`HQGUON!eCtkE0JH4HVIYCjQyqz!&p(KmX=oLx5+S zfD0XPoBQ};N(D!$**tpWi*cSM562gC7E!_j{`;S12s2TOSX(ppSPDEVN6c8@qeYyp z6MV+oXM^#XJ`i8bqte_QUrf3)U(7d+urWuzn62ZHFJ{oUe~vFEDsayH1A;LAwpo6${R6{KHp5H>P@FoS;Z`3TvJ2 zrCP=+&6Er}PaV~n#b|CeiOV9cDqMS*?b;2G!6x+!{Nw6lxohtY;gK1cnOxK(Ep4_o zXI3U*Q4(&5+(u--v^2O${^JSLrsQg8WF}?<_krX6CZ}V~o%3BIzd8IR4NXa!g2|Bf zd+qLcuc|LX7va6$5bjl;RxuU}qMBL@A#e}E{dvPS_iPO9VUwB+{~YfxvR8WcRPBs; zwpPxG+1cq$UeB#@4r6cL5EhtM3|RrcK$99}_kz>G`P{@I*HhGG;+A>1^?&$P^Sutd zr?!M&HT-4#D)NWF9lt90Bm8RE0rnB%SEpe<2{Qaa@ToM?lk{FgaZdyxVMo1&f{?O=epr^!Hx0{$ zur%SX^*rc`tHf?|ge{o-usBwiiw{|ouxH_}$$tXJa{CiF)+53u|1+N}m|89O3gDk@ z^H^5#--cyvp8GdrSyc~;Wr_avh_I}v{?`HoEDL)D%>DVw#s45ID=;LvAQaqNnQT+s&f4`m7TrL&JHp6`C{j`g6b>J(3!vl~@8ksyUYBg(NKOAx% zalhcAYI@+BQWM2arj!X=sGOnp_JUy}!wjZP{p*5XU0WRJ5!<>nd;Cgo!h~P@^QKQk zZ+;R6`KSntz1lOUd)-N`X-4OX;eDwLiw3%uGcFr@&VFf3{^o#DTLu*BzX*I4I2}cL z3NlAOeDzwOhZprJP8ouaY2a1xNBhDy?~kG@N^SYiol}nzBU1^^Sc@2$^UQlVj11F# zd!=n3`yiakyw}j!-fIaX3$;BrhTtT3V87+sR>(!;t%66?Ya$6H3H;{}lM3b6jgUj; zh?B9Yh?6a<|8qE5k6%*iIbLNBC%eMqWY{R8{sDQFIs4h3-^YXwrNSGQV9$46HEJs;eY+VqdVTn zC_*mbbo}6o?Su3oPuJT%h&UPYB=?P~LCYz1T_7#{dY}vUJOtS+yz=OY&_nn(-#T+| zYmU)Mcy(sBir>e#^K?pHjP~BiCz=T-AKZ~s0G58dBDldnWb-fl?=-k`zti|t=fja( zHhy2&7d{s%KDbw?R?L~vsSivHjT_FIoVnPt(=Z!a0^}$&X5kJqlzcL7Cix`HjZu!N zlOOV=10b^vI#>PNMi(5ZjCW(qx_y&gmV9OMJgeaf^<7qdc#f84xyS1FK}!P9q6pxQ z@}L5zN=}NQIf1wn6!#twNh3*IP)Ixp0T2&oz8Dn=X-R;Bs+>zk1Jyd+c zYSAk(s}7kP%To6FOi>)qm6;<{;l_4`4yRxIm|gY6H8sURi2__!z`l*&yP1phxLL7s zpHC(W1GkF)#^mMLI{T+#CY5oLRW{pV(m~rr7k{5;Lrl;mMmq3gulDR@mZi4ozn1U6 zB{g4PCBoM1^&b6mlv0{Dwx8P}3JZW&M(pTlyj3AK$0VH8$u>p2({cGNt2hTTo>7dy z*RkS5E0l7&B4>X6b=haJ@Q^B0O3LC!$)vutzQfgC=DJ?yeO*r7=yj^T*X4#@-s0zn z*P0ziOz$St5$oNsAGc2QtqO9N-6mq^co>pAw^s`rPDV5PI$=TA47z8X>sPyB7I?E2 z5vq=)1J%M@F|?e;R)5de&P(`yV4Py`2TGcf`7bYk`;5b4jYZ10YCBZr#wlBYfT)kB z-_2hj+XJ;5$=DD~ne?lKURxO`9bk;$#(YofU)8xFkhmwlO}svy)J2DM56Rrg zbY;#2?Goiz<^9_`$7d^y3CTJQIMrSC7);qN#yBcN*?so9jHi@rX?dTqV?=GLRBg5- ze&Wg$cXipeFf4^`b41(D0?E3&_MC4wG9+OM^waRGmQ!02bK#f~)=v_qx~uYHCtlR# zj_(9a5!k5Gv_#0(H7(IVrO1JK1?E{VQ31n|I{Hdmf!X;=TcCOktNqGTe6E*B6C=lB zn(-2eCI)+7!j>4Ap4U6J0G|(~HK!P?P?;|e5I8HoshhfNY)M#+kUG5iUtyE9t96^l zP(Iq#rML3=hO)!tdCMlQu2>&-M>w$4zObp<)s){P|ADQqZJa1kR&{`k*Q+91WdQ)dY_rhV}73OxI z_K=r6`Lk1T_#Inu_#G$?k5C0Wefq2I(_isZeUQ_qzuP|joqX5%Q#q`UN%>gBB=@#S zqFHD26Imm9l8+JP!ADj&Gnio{K9UQwMhuv^E#(f768+aUV_hnCc z8S8PPy>!QOOvR*F?6ft&HfRIvgZ6su!T87|$|JOGX<@^aXl7BUzn`u{?10PjBrgrY zVtY9K^X0!SR7lLoJY3Z=VuAlU%ab6G%a?>NJ520^QIugT--_4glN zwdK?>{&*p`-gbWd7Qvbm5rQ)XOSxZPnE_;$E)@LXZ}`9~$@j0}QU2*(oF%B`j070j z0@6KCjopU5Sw%=pgoEfU7kp~-Q)T4$@!ijKB^mRqdmHnlFr(* z{J8Zf`-X*mgIV&bH#OrVG!C-cr$SSvulXV%;Z@6d9Gh%IJ?m?n zsUw_^*jI21Qf#kni9#mO(ga3%d<t zu-PWkQht13{4_dS{I<_2ULefM zc#G+kRN*9no>Eeq-BIU{Ld6~7RGQRQ5I>{srAgj9ea=Ogqc}wg@}z6&37?oianPbJ zd-r9y*lJCpZ7q=D*=uDK6$GyjJ->n*y!6nh#(N^({~Zx9p+C2%ty)cS&FQVG@6{#A zN3Gh0pxpHsl>e!VZmbe)Ga|)wBK%z;pNcnrITOPiC_|gy@pHp9&M4;mRL#OF_#%G( zNY+KMeO)wrK7PG{?Iy$W6c#yJaG)jq|@9!ywNk(ME(CduJvP@8Q12< zts`8YfKg#|-f#X;_>G%^mdjZk*Gu_z_&r}{IFUiFu+8_)V~}6jV^Al&98%kl z*VoN3FUlWY?fG83Pi9!eSFzU*<7A3quMa1Kb_wp&o?rMw-X6@09l?#}YvXg2p)5Ys zsyLAD@o#~=S*8BKXHXX@eY~u?NFRyBD+h;FFJvRO?W_Mbb-E<=tIVOkVlWk1k*F?p zdO*53YpCxF{C@8Axmj6RKRCCW>jLfODt3&?Hyt{xdS~srz(~b7XqKWI=l*KzGRE(^@rtEfg4IIZW*Os6}P)9n1Q>a{U{n%wF&+D@7=O+Ad%N6^LQaI zdK9na|IE&1ya8@jq-!ofNu~L%*4nOf zKaX%J#=6RbaPO91*e#WhlVxi02kM~GLVymk5jr^Rtq$Of_U+J9Ah)e#8yvO&j#U5I z9#2;kp#l9Fz|ylK+p*v$PKOg>dj#E%_|M&PtS7FpRl_f+!Fv$9X&xus#?deMzv zw!d|qX0@zpAYs-i!Zr-^zU=IMN7b=ju(!ew?=0w0?V|vuo%!W`79e*3*W3>0*R$eh zj8~Do1OBu!ih37beVM0i`ccS9Y@;jn%1dw?6nJG-z?D@TVql+>f=mAKM@=C2L+R*yj*%5W~M%#g3C^VqF9iS3CK;2d2p((H@lpw zj)Hap!v2rAFU9>@{JhJJuHMu8$4_`%`odTU!jxy0_9)b>E|ujkFFLX!!0%lU*_z{( zYS%pEx@jrTvtuYK2Lq7>%%3cv5+XJUzhrJIcF?O z>Ma9XMz;$Mh$%X;gUW#p43A4$ynRVnYM4Ri`3W|2m7eZA1pw@_0flnuCt0|eu@3wd z!@P#aCVf#VMZzk`g3Ffe+60sGv_M$Z*Lrb3A*@+t9Ub$zUP)ZuuPb0zjxes zvmD@v(~e&FOS!2m+Stb=Zp@wp{Edojq_L02DF2<9p9-)0;wYF2U74qhj1#b=DvS6ek~4O-X-__ZtyDT4j0&FsL5r@B6^jo3(99c;XjBI!lhlg z*UPsEmIXgyK)}*s1apW!)fJ{uSi@VuBM}Mhr4G}wz`3sids&f=Dykn?Hs@7&Lf{e+ zrR$cIH{xaWl z=0X`PckChK;zWGUHS7Y{H5~P6fIDs7wJ<@vevxabF!LfE>FCA@Fw%5a7vm?L&+~5lv61!XRqu$D;S+#NQ!cfUX~IyE@fYko z<_QiIAW=_bPHX{wV zD1e+|+LS5NrY3SJmP2Q&)%V3H`wW$wN`igO zzc%wc736t36Cng2FH}bY&z_lx%ma^=m#HNxkM)zFkMJB2NwtakDTO+}FX9p+2baw} zD9;XDy>{rQ!EC%p&$ti7)@705Q$>(g`J3AsKR>6E^3?)JHQH8EuKcaA#Bbf0e0_;X zS)_#rq4&{!x>PCoN}4Z|iJQ!Sh2e#9k837Y*|!UCQ}NcfeJpgZ^Qw%D1uW~sg!-Wr zz0b%{Vkk;zt7f63&5^<~1r@b~HvWUr({VJceTYW{y8xvN6Ey*h3O#ESy&!QtQV9O; z>JDGTL2tCAlYn82ib~g6QHh0@b{!#A4Y5+PP<==&Ow&OP5;Gc^G+pf@@!;l9Hn|Tj zKdCEhbMwWL44YI>+IhZ2M$ei$ZAM1sjLZzo)J;?;^+}tSJ{e{ZCW&w}DN#K#5)*d& z0UhPE30jz2iI|25fAD6^B<;*ei5Pyuy}p^#XK8cN@}>#z^iIPRVLpKw<5ZBZNB)58 zq;FaZVJEid_C6QDjj@FvYfByP;g9%~Szq0(OIRq<&hmEDRK) z@|ZV32S?BnsaT{zHN$L)-HfHEm4S+ zC+Fe&D2uSZgP&V_VUs!t!pcz=MMkBi;p|Au)28Qesp5V3cO3G?o0)M@jb~hMe&WD% zih>h6O1t)n6$)Ucm}E)Ge2sLr|7k6U$iea3$}Ad zUX$~)$5$W4%_gm|ZghJcWt2^Ra|CC}mKXSS#~*Yr*?GSyA#eMV!QGeqSdKD27^f_Y ztgn{c2wYvBgljVQnXL4flzIkZtF@CmCS2nz*gfpoz zSO+_!&z~^voV!S_>Tm$F! zi(mi>1BGpUmj#MAi=i`H>GPH%iP26=>iKUoE?_s(S0(b) zH!3*&HWOg_2(u!|iX5wME;?fenHWyG6$GJq zZL9r#nLTdrVImJgROLS{`Op=DXD`D3H@N>*Wlt|~X;P3oXkOah_8lzd5mGSZNg2sM zhL_A^-Tb7~41HIn_?SuJC#H@n1J42rZ*Mq$QCih!!D^HAh$n>C1N4gH)F23QQBZZF z`VPj+CEnHG;i3!ro{4=EMx{tK0==ue@S-2sak;HFn5m*}B8Uc!g18VgO2<}4PpqrD zrSl69pswbp>ZGewF9rBz0g!3^>2Ou4$n}`!0t2!(pr`k3U?14CyZmyPMuPmW~)eZX$ z>BLLYIv`Ja4V*2@eXC>4E5u)jd4>4fj15hh`!lWQYgcQo2WZP(f12L$7w%kGGB{S=JNh3D`-5PvZmO5GjQK-3Y5LMb*Zkk}w``1l;9-;`(!@=R%`JW&NfDO1@#&(`G z2*PJYxp0A%TDkEgyOdg7UzooHF7t);fRIS;rhk1}Ua+JbXTZJsj|te#`%9`i|3M#l z1x6Tnib~z;WvQ)2DTPav{o?}iS&ve!OGto3R|Dr=;k|TLK&f}g`~XN|szCgqpjYRq zgIUOx3Xw_pt0}PdJh`Jo)M&|Pft9R@^%zl(Yf0k+Ye_R+@bya5wr?DqQO-gHn7@Nh z21)u44Y*-mGHw!2UvKSMd$J>c9*bIv=iwjYlw{)~)|x1#AZY`!=9uuU4Ki3FVpLt* zBlWjwADH0!SctEli%<=f?_v`sO5${JedA#f@XOTj{H{4&ip{Y#Fj%_6xsz&i5{Za6 z9AynJ9+FA zB)k$_`g0-fA=nCx3$4z@SUrK3fA3#48W63mfN1IO_;(u0?7!{BROyo6*dND6$a^A5FPkI1*BLqbt&Y=Dpmg8F^}9LMYX{jf>h`hQ2?M=EAb&7KY= zZn=3J(_d2x9+kRa@}S~R%gE%kIvC7PKoWi;v1Ir`YvpI zrtXTe+2;ie>t}?(+gFSdUE2V9x4UZjP5{9$URLfOO|u&Fh8%$Uv# z2S^fPr2u)Vkx@0;|C?ONq<8kieg*FD?-}1+=AkL}E{GiuYU7h}dk@J=vI0AT<0${} z#la(2q+|8+`zVU<=6_smx^+~}t}n;5%y;F~c`;%rxLiRxq$CxuBVbYZeG7FA{-3kemGH`~U1kBk zR|j_f{|mNy3bco_ua|{EWF3H>1m02lpYq^NQu9G6-?Ogvd3pk=j%{k}XTq5IGHN0t z@pGY0I@+5*XR^h44GNrTENRvS@#y&afLIHfLuQ(I`k=~=9K)m{)e%aThgOwOAEy5W zc5gD6p3->bakM2dW}u$ae*lI!eBod^GD!`_8ak}TBbI-<9fMBCfEEHqa23?%1sMZy zmnMiFBACbKOa7YMfM&N&1WOR?Vz6C}V2fR0;sM^`fO0z6;~u6xE`yM=-(9c*b5C0q zy7{@f=rT;w$rh6W)?mSbo_B6+QU)$>FKWlFmI|*WJ{|I<;tKc@nBl6=-~N_`m@FSQ z*$`vCqSZPvok?KH7U`#>Z8;;{T5l3hQo}zdrvl|wt-5Jv! zZu&%oK02x1(bqldc>C{p%>e-lIsgf zjx@o6qlcid+xZBp|8!W9TWJJ`Dcj*5e=Isz8u16 zBXD!_>xHvb6cYts@9ngj(dA%+Xl2mvi5$zxJxFm!-TLlW?tgGZJt7Pyb5fj<2|ULCgZB;L zB$%)Qwhwj2h>t$FXM-ik#IbpTcWmyTuZ)z_6D{DG|9}btj4RIKp-{_WOuH)unJjCK z!m|*I#0;l!zK~^fsSZ`l5%u;zSL4*tyYt(8I2ko+KW*o&Z!k(<;XJ z5<{e^InW87u`hEd*>V(g3UFt}3;zAhOMLXSLcu$7!rek=Ebh<~?eT7{&wZ~kN{{B9 zAHal-j9PTtOMkQkvm+u;czIUZHj5dY#pQhfsgJvrBFYnAi-9Rx0 zpI?{ljIV%8A!`yVvr&Hv*JP#|}X|@1D7jX%XpjwIA5|L`0Tu2LJ zS6Vd-+&xhv1x15uWq&=qf>W*Jx48R%WWUwm)(=M^-u@VG`1ga5F_)FM^Uw-cOupbu z3%7m&U0(*%fol4`b#W zEZU`Ufx{i{mD9I~=kRz+2mE{v{A=u!IrSh=!0NJxOZc7v5Q=l+0(zHw9NZPFehkCe zaPUqm*T;1^K*`?J{0oKO1sO#8A|TwvUsEt_Qt0mAPcwJ zd@d-MpjXNRgH{40i7r8H&n0Ub@#Ew;^5gh}j2B{2oGvD~6xH3}O-+{Itl?xN>I}?@ zThm4~Xzg*2(pRfpAvV(3FT3KT1EamW@p-$#D<9+F1KYbo_?Sj0ks?KL)T;V`(~*_z z_G)Zhjee5mm|+E!!4d$!HZS)RO!k8;+`Q!qw#OGyXVD*H&n_pbRJo!=&Y;Jo!4wAi zd;iBegMV@eaC-HrkXW6#68s!&1oB~8(Wl-JzexB<;xZw+H*XK?yZC0}{KX$Nol%Wz z4dD*VYCcE2$&ZV`q1y$e>K51D&>UWE?L|qlFl7AL1|RnCf8Ap@saq~+~~K#VH4sbl>x0|VZcl(D5ZnrVAM(=kH~Wy zcL<00s=m?V&(SK%B8EF^kA@rd0se-VfgB;_v~q#~Yx>NNBX5$#p(K+r2;wLg*gA~i zM2u19IU>yE^I2mDo2M8PUUd^=PnKXf+Z=EyKj&OZD4#-?vI7YmHNYkAW}bmZ(g6ym z*pB4e6_|?B&iB0z5*ly65Az0o=cKPO9H8aM%38Or1^q)I-T_f6%=s!m!t8Xz`-OnB zx(hk&hFB#v3XXu=dL3gn`XO(?g@Tsyz&Mn0lm{1{+Ig!#hNmvDRk3h8@hJfB??u(r z-uFreljz;bSONLI5GnsoWqs}{dv?VQbvF*+zHstewf*krByU*2Hni)U9h@Kp?@yWrHn5&QG1)^{Q7V}tFBzt^*H5`^lFgRkL(3iaa7a^uiofHf2>wee7_ z44{~+wS&KltHa=s5WOo}NTPR$)mQ!VHyA0s3LXXYo9LCKD;~gIqqX&2?i%UVc#Yw^ zne!3mEr_EdUiPfv=$iMW(`84`td@tB%{w2pVF_2X51(me6b0tIP4@MLZBF*ZPliqE z^~N@)qmKk)jXp(X!_%PryjBh)2l*`YX8 z#8&-ZIDWI$IF@jKcH5L6zvTEA2?8LzLaI*yT3Zrm0#!dD;WbH|EGk3*G?LsV3}XCZ zFboZVhVc}OpKGH!+drQ;2q8XL3vvvfGKc{(vDSZ78n-SN^iAz){n*xYq$lPUBLGO9 zF^>fqnj}NRvMIeTU>1hHJnDZxW+BV6V-}#6y4f&`1h{9xCP4duw+RRjbdh$@IJaFLA zu-KtMlrdme~cG^I1*&bv#?2JHZ0>5~mlBBS2Rg@+aU31W8CBDS-~- z?rcXnVhQ;r4p;(x$3LP4EWwCE9u!bn$KP7(SE}M_cz(^M=COb!2=kc35@cBdmQb5k zV#5;R$n$W-5{}*D|FE=+$SFI{Wg$Fw6aOoo1&1=&-!dmVH z+uT|W=X|oE2{`^Jzu8+wmAok^2TmKSS{4n9%|% zP2vDu6EBfCz&k)E%F9>x4LD}_r1Ky&W;ZTdmL8=A;HtO2$V%syIr3>ItA z;>dKU=E8dq;Lk1izrI4|S)_muEWZYr1tK%Oc&x&3l7kT73P~TK!zwDHCiV1lLJlHpqQoJ~hEP1bpMqo*z8^@$FV%Fu5Lza4OOYgIYl{(JK&j?t8D&vQ!D{Oe>=( zmjAu@Z|}QUTfXP0w9|kf>7-Rw$DEF{qrtk63ePs4oQLaK;{w~5v$5e8&ScCBoY^Rk zHvSj>*PQ4#z~CrG9jTH*P(cbg^o1Y5L*BmFJ3U^Pp_>j#Jh>2GcggMi%>c>#UxJsv z92w|A?hwP}aEJT7L@ADUoYy8ld*v!x70RAJ*f(+ley8o~G5DQpZc52m2&xA_f&dpk ztiAi9-^@Hmrh&Qe*>KD`y5cU@@VP=i^&B0sE-XOOl`_c0imdh#bjcKnL32_j5v2=w zs&oD-r;mq_IPD*gi(wsa8I8Edr&2i8=0b8Y3B&lg)5gfS1aZJbK2@EXSa|>w9{Squ zr()-_{a#C31#q0{1$TNXw?ozeNolBmu5zbKLEBd##liRq%!j@AVlAsxlA;m)%FbQV zPha~=X{|&c3;1mo`>o7Whx;PTf%|Qi?iqPW=fprZKEL#CEC1-FrgN9%>yT(&Vtk%5 z=(4zMq-^#at%?u$;h=g~5g(z|+ni~oJ9zFH?9l)W{p)5C-FpgI0#4!H08e!S!|E3wShT{YtZ&I1X*H} zM~%@p*Y}aNaW6m}_CLp1B^?A3@ z%;cr317o8q`hGU0k}a=31~9RtpNp=+MTTjt(;3DDmqD%vb+w?k5s&5dHkKSwZ^Az( z8~lOnMT zq5rP?BDgj3rCJTy8WSES?+81Zp;bd3OPHEw#b@j#qw= z;^gf03I-Adpd4bQnAA&DWDLW#m$2&~NLr|$TNN0ooDED(GVx0d!1_hx3xe)G96o?mj(%Rc=8h#nT^qCM17Z|&q{Gk41 z9foP7Sj0-$eA0Y(1m{Ar#&A%?XHCUvE&{}wgnARFxdcckmhqDnXIKBV-9TwygpoGgYxT1SOxaG5qwR8~Gpvcz zW9NRPtby*WNzcjp zyJ_Xm2r=g_@THwqK z_O)q~GQ{6J)`Gto0lzJbEyl}uz11BysdwO?<8?LbZ>nt7P{=ke`_aS656pgbOD>K$w>DbAE73`79p|5BMuNEO#6FTDntL`~oP5B> zb~xl*>Q+=p$T_3EZwoJ;e(>7 zUuA{&6&ZHW%3o;K0IM2F2wZ$);=Jw7VK6$gZXI7-E_>0wXb~( zE;H&4_~$e~0m*PwW{nDJ8)-D#oW-T@uy*))z+*K;^mBQqSlztcBu{NN@06EQO_L=DBueB5WzT-GUE(=*)(cbrjb-?qe2$ueR#){{? zH5sxQtBazc#KmJF%-;HU$92f}cA0=}c#aIL`cf-d8BTph>)6mhS#4PSm*6OotnY|IXh#CRzV`VkA{G=t^6rw7hMxy8 zGM6Z@dHJ*teNW%7+kk}|r=&czGKxZAT&Nx9V%1IOjoIg0JehB=!}lEL+r!IgNVAM? zjM3U`cp_(8&z_t6=6hk_Fkmn8A}L!B zv>V@nH)zd2GS`)(AK~&5T`P{TF ziYK~gSEI3SRu?tD%I%=!&=h|G~>Ku28h>B}YsW zF=}Bxxxlt#URboZ?fD9I()=sakH;DX>BzT*_rOf3IFd%H1N-iAoq9Tx;Nc=089>d8 zWdjs`;5Gz7eI)n^VHqniap_bwdzX@6#G0jPHX6AUa-*|=OF=>pB1a?u8_BZ%qR;|S zd5k9{uXlz7sqaCW8B*TzIm|+7V!lW#qbT$zP^a3iOm&jaecd4Nyv31d4ceUWm88=C4r)RD8DAn&pmw? z1PAfiLw9=ZI!B*wt&=e@!{I3-NLIUa*+H+ilf?*tvH66%B@{z<73Y|2w2TF@DWnz= zUQ<9v4^WY zUuv7v@9_3G$(OS0U<*$5`*OIj#JmOj0SGw+=eP-bA=!q(92B5)sVgpJP)#v4X$ZgA z21fsEEDj7eH=JXXYPc?6hO6(x&n=|e85aw~BrncBkM9ASgzL#sA3gZ>qvzizdum?h z#2Jw9JYgDCv}>p4C8l#}YA6?-YuE2h_93vMs!Mv0IH!Vi7lxmc zx&w~+k7}5cIJZ#Va`l%l$2^IH0)JW=1>G@m9PRVV(T+s@$NM?N7MlO(k-{gTz883>J@vhGXi@HAD zlaJ8Uy1n$7$Ckt_U_MsXsXD!1q&($V<}Gp;$csY*bOS}F!Bj!PE!z~k1B;ZD!)RF< zQcBfJDstjv%uKP0nmkc6>Ye9!As4+fFP)NO)F&v0fA5nk#5J%03%{*4N8ipH7J_564S5jaypSD$)LTQ&**p|-%f^f?*7E}b}>VGLdOAMnG^r!mEkqBUVoOw6d9 z+)`6PQA~He*t8I)crZ7&ILlO2P?noju&B6*Y7ZP;f6z#BRuKiy=m=HDf@mDydGET6 zagD&Wc$%*`4!F3D?cS{hOTCbV<9PXXK^9)nl~9139fK60p!w#KToIalz&SlfQW0m1 zi9Mt3FSEw|o-%<1!WoCwebs~laK_H9-ktf92Y6;$_#>CBsh^}KHO9^Lie`P$Wa*#0 z)wZ%@;S*JR-a%h97CGG1C%xs~7wvVlsy%7z&u`8~mGAd^u9T!UENKYS_CG+-ayb{Z zl>M!HHWrnv6|rjWgHZpg{R@=mBYmSXGPC17lDBR#_a+@}rN>xO%$BRJP_NzUsf$T5vGZ~s3dq^n&H;IT zWvq}KvrYC~KH!55b$OfmQW5Lq6;BKpQ|>Dti^Gi_rxew)Kb~oS@1n{j!=tPeg^-k$ zMzJ>iks0+_y+$JZPgVJFVKGK%A<23>M5!FOhU=ao`V-|#!<7u_CWGg zg*}AvDRMD~*i$nz`E&iWXHi>?bB1+lRnV7;ewONMZnK4<(hT`ez zGuh;Z-HOeMiOXBIctL3a3UL;IBbS_{YQh#^4b?}9D5IF^s>uOAeuDZ~~KEqkRfT&qEg_ifiYbSE9} z|6w2AM@$Cs6!_nWGtQIcLe5TCqeT3}igjN)vb(oBx!)>a|2u&F7t`O3w8^9I<>XUsd+!>}3w z`|(18m2vTjMO01?l@#NA&-nw6Yfc!`u8|PAa@w_d1N_ln;%IRD+K=F*mg~6PxPUlc z35Vs{B&F<*c2O?myP@WEoK|3LHPdhS}aERi&4 z>Pz=q)LRmxpqPGGcGW7hu-Jv0mAPO3M(>H#AidWMOUJS}QumEs)_w>I313%=8ls;hf}4t$E$XI?_}$4ynmwPTnu=> zy<%9azXqD7d)4C(Fez5nW@1|tcdW=G+TmcJdP9sAUG0$`>qNxc2jMZl&ReK-jQb0I zdhi>%_9l~f2r#YCxzc7Olr1U9VU3-WsaaWfeg*6-c@Tm>F;yDJTo&w~xQpDf->?{*J+!xJXOiwuUy22-KiIC{M?H2ZyI+vs@~%1%S>^7>!i4J;eRRCV1vj~ljf#AD z!B5Y?LvDm<2fOGZ#{BH~l>M?1`4{xdQoJVkT?crj&Q^oaFH5vZD2Q;C8&vBzDE;<| zLQkEQRYji5qkTP2+E8rI7-mt!)?B4vp201zB(9|j;R8g!${lv$iaOl2=xzEg|3q#A zX6Tcr4y%ybhjByEe{)F4>(40It>`xH{5cgBHx<%Yh{J8rNzsN~|6M&hB z|6{8!qu<@_ArCS<8vW!d0dEkH#InqZAd2mq-!|(nYD>m(3=I`-XlDN*4IU`d@vVMl ziGP&?e{o%ds?iEu)zF<^t1F$j9;Z1MyQJ9g`dzv&i%y z$#)h%%E!{A4oAX^vA`IU4Ko)kTKsU<%&g*q1w~6s;+B@?B#+L?T~GvFy|i>*oUybh zGbOVuGo6&@GNJ5A!vanvh6Vj!-F%|q1ON7rO=CYb~ zTp+O%jg+^3D8KGqbrD`SX%JK6w-_6-&u-yAOY71(W-V;Y;{MadY;+clp2Qy!#wD|w!RMz<`2bF7Arab7Y@9k+E zT_^33Q!BdinM`KvceE=9cC6Rsd3)XG!_}{lt$E)omCNfd537q)RycF&uJcmNsXO{> z9Qc^wuRMr^EspXVU#+t?j)2y$iFDtV=GRHIesS9z_gk>1E1(U9XX&1c{TjuiOR<}M z>1|(qMoLrm#t~`zHux-j5HvV0*22HPA>#y$3vt9US5`gf3x*0m zcf{+koD>l5`fs~l$CK-=wlQ=aq%*iI-zvF|G#sb9xfka*bgJN^JC6J$DqP8b+_g=p zx^=s?kSWISc_wl>QB&Hkex|NPV~6@NX)kO{DvlitN2HGGvj&9h8L6m^nu2@JpyGic zyZe?#jE@?+J$8b3pXQVMc;bg{?Wf@);#%K)pZ?w>Nta?roLk?iezTRt&as;2dG}Gb zHf2mblBAA{Nz%U&jwjk$Tj>cMw2JY>xp4G^DYvdXwkXYDb5YXnE4Ia$t>uKTIXvEU zQZ_POYoEm_=aKNxBT`Xplg7!zFq{&``fN92y>`9T?ilNb^M828sSmxHjkT16$;U@{ zn(^<6*CzNV^Xa*V#kDTfw8xPUZ2{jT5iUu55xD4S1x$KG!XBbmh@PI7UO?^#`%CGjl=@h#1(*>uC)2pznX=7tQLG@{UWh5eaMb3?|-8{y*> zm^E0d9fWMv=oGqDl1X#+UQC+Gw%Fk`X%4RuCe1;LH!jkCzAyiWcP_QYDh)WCy-C#? zKEtJ+eI4rAGpFHe&$PCxJikT;hA%E!eJnp2F2UJxIK<2O)wADurc?9&n$vVLqnE}7 z9ztiu;zMc}wP7KY1;N*Tdu1*HgUo(*t$0wb{iDRBUiZNW;kR)aN%Q)u4C{Im4lG+@W}~ zajYiwj*uPTyoJUh+|j-58RA7>WgyrE*$T_AJ}5D;%v&1I_FFpXRW>E z3~z6EtjU(J3dWyapTMy_h+$2HY4f&2!JzpuZngt7Ct9skuHwF=d4s~tNK686BKQ?g z^)9B8+_VA^63MEF_C}Qc?S`|+v%XMjN#7${72ZO`3u3=gPK9u(&HLLKir8+Dp<{3 zzS~^sG2c%&6*acZ?B_1d0dWp0&SLSMV>1xSeaXL0z7i+v#oNmeLS|= zoYB*KYc<#c$hu(Owa~n4G18tC1|=Z_PR)L1$Dqj~C8s@Y;wobc1H-?4tz&Q4s`Iav z=98^pWlK>Z%ZVTREj&H#lPOu`>6tVf$Hy1o3yh6n0w;=(9On*=Q{A| zdu|^UL{$G<+7S`67JW!@JS1yK?%?|DUY}!2*ywdS4ItMt5RjC~mtK;4vf~T3nAxF7 ze5VlOv9ookV|0sIf|uNklv_Oa-2)OVyLn4Qu;v3{&U6H>J?uVb zc6Kvo6qESu8gGlu`DtE7WzIRX+hxuW>fPPmjXBbcU{LA5?V?!}1*%HA%{tgehYi{=Af8nRn%>_-K+*GN9>aaR4PrBI( z=I!3vHO1k7y%&s%${A@{%(X>T2t>u4*!!D3`n5O6$It^Ce?xeS;Md}wX4b7aLH871 zExe2-vJ<9wO7aEXCbRPKk~Mb7xo0}5#=T*hi&yFoz^QXgL+O;Z^_^BYwV8Irr_E;* z;Xb^UfB79h)$-f=Om1zV`J+_WU+wHTzNVGEhu2YgE5EaE-_jA|Gtp)n@6=P{rmxpI z`5dk>vN)$4F1awLaPrEZzP$@4uM>^j5&uZcT*GmTtE)VM1*#^E$OGiHbevdY_nKwD z{ubTBCUi3)Mml2^fu-&Un5go?&1USCVnEIQk?@##T?iSmx*AOBVl-fyx^E`AE8Sv# z-P=eDvyuP68gj9b|B66O+&OQ3{Sd<7K`-Z=?)iGj>5V8b&umQUo{t}Z>yTn#its`_ zLq7Q{;yM}5$A7>>7+(kFQsHwvgKpYFUtovsK`j;`w!F*Y3vayj^Q~guefeZg%ZA z^82WdMpuIeAH17e$vf4sO=Q_bf7>mJ$0s2MiTALA498Sw9+d>Qb2C)h00G@-H8^b9 z|G3$*^~{#hcE$pzX0itQD1|QhQg{MVOAXG{()kxGYVBu#Z+AkM9p5dtc4mY-WUhIg@ViML0>Ub@=1j@4dw zIqchh%omZD>WRnFK9$)U@5D1a#^c;OTOOz9zWVpgF@7feGm{N!W`i-0fFcDDB+f5hi24;mO8S~GRfT(N zU*FjTj0aOyPwj&h3n)Q-Ad`08r~sMz+?ce1p2qKnfWRvBliE5oOmW^YB~JreGKt?N z(FJKYrmpcRudLwaODX^_0ctKGw=T13M4DIaQY54YYd~c=a#3#H7Ml@e+=y-#?M+mH zB7c4CV9=`)QQ~O++WV|eimLZ4>O?oO@=(KI&Axg5ubEx_E*+ULm0upoo0FlB5b`rfKk1+ zJ?6dz#kmPyvCD^WM{|1YxkTtS`KyMv9kB)YruKxir?(KF{AEm4W|QaQL4abGr0xnl z3uWqgl=mDsg+)a^Vj|wl+fobj5x@C2&GYHZXbP5_1+32S^wx8@TWiZioXM23SG&Z* zXpIE?b0VsT3taMRpSc=N$y{$=D)@(HvSn+7Lib|v zbUuA-o-b)Lsb-qj4dfEFr?gS}DW1lq!<)fEv49OG4#+a8^yR|tUJ5A}ZcwFz)*M8S=BMmf%@zOOnc2j^Ja z=#Ohi4XIC7QZGZaBRZs2wnSIfD6sSw+D9#-%l;AlPd|Lq*Yg@Y3dJIlwCm*$pQEw- z!f{`?8S4J+b9vru`!Bn^AdB z{JX3BDErbWMma%bLl{0>V2=KGEp+D9w_l6qFJ~7Xk=O8#5i2`>cLo<9w33R|qvXBD zrC+(74eNav){b!BpZ0hXjj=ThW$N<64aP6i9*J7{*SUB2d=ODz(s&Sc?HIQ!X^-f7 zq3sc#JYk+UqCP1&lARj2gFUj0106eES2M2GM4`PLHuHWr9j)h?P3C)w@|-%M2MteQ zW44xXU;%Skf`{B||0Y{Yu7p$ykp32ZQYi*Zb{Da`6EJk?2SYl2WJc*<4-7u*lU+CU)Fn-P+fB*aFRlYOl zz_ri3{Qc!n`KDEy3Z8lgN-#l3p0i)lXm%~dcMZzH#BYDDX|Hi}3)X<2*P;0AlR;Fq zN=j?z+aB5d;tLnU4hKI=Ox)+gaI%R<LkwwHI|9KqN( zqt8kFlteiU{h?D||D{Bk>6ME)r3vGPwntor;hz~ve;dQNNgqUnS>~<#W(3-6&g2V> zH7n-%XTw8emBc8!qK0UPzex10Tmjql{TrB8HNigZ5y6XGTKFTt{YxeIqCN;&4Pm;Y6e&`uf zB7O;*zIEqA)5#Sj9f#&W-X8g1)1XP}xd0ADi&||40SN!PvtepH&-}`9V)RdSO!lg@ zg-6M+BsT#^lx2l{8JMX{koFTf;ev4zSR%&n^gV_IKIcdN=3x9S#O_3C;O=yrW4AU; zWU1WHL1bjTIdPS*1+PtUTJ)}|#|J+Ok{%yfA)m5QfZ(k{ zVSm3}T8 z67LIGQaABF5UDQlzWwQ{3`e}*eZJ6g4~CWd9zRk%@3+E@sB0qAjYN!Q0UJ~xwL5CR}YySPr=XHe0G9B$Rd z>Q-Gfw>3v_d>aQFhhC{!s?0c+10{%i5nWfOE!gQZs2xqMySqM^46-FGXGMi+!u~WC z54p?uk>0 zdd3xLh$yIr9-*1QsA+AepRV`%y5w>Hfj%{Uo6rMPtu(H6@(aDU;!y0LNyBmUM}T4) z!$`;{Y5_l`y5uQ5;(a2zm!!>qJATLcIf8$YS!Q}$aBW2_%r3gP!dtODuqGC2v4nl5 z!!$OZ4tOXOg$@coN8{jxg2T0Z$$F+f0bx@k3DI{#YX68Jv-A7>+FAOvJWXxpl(xZN zpx4?d@KyML-RnN!Pp7n@vY6WSIrb5+!kMrJZz5;nVpS7dORsIpsBK%qE6ZM^Ao=tK z5UH;don>6XjhXn)Oqnb*IUx-L_jd$fTi+*7<%GH9n?_kZ+5x5;ttsrq69Q9Y%KYpw4?i#VRgB> zI`c_$$vRd0XJrp3C?4ECDzGsfO7U-!@O}6sU7-$N$pS+8;YXiE(=}2QENg4riwGdU z(##$AjT($_ZSlh(XO3P)Y)i{=LGg7GT`Cr7$aN7J^@iGu-yJ=HJE~C4~U!Tb3 zxiv2%&BZp0KC2=_@L7c&rsti;T4%QgD?L?4bq)Ka8m*FrP+F0V@tycB`Vv1^@7`0G z;hu;l=B}$RXO!}tWLLuHm9YM84qw+bcdujT#MeU7Xwm*d|0q_Xzny!}H6giT5aZcq z$83kw9)2jj?UT=_@Ph~3ifQN2D029x!SJT1g>t%)1x;k}qY3cTG#pANn~17lRE%#h z+E&aXmH7u?X&1NE?KW;G*UAgqBQ|{w#Bs>F&GGp|0kk|vX4C62;pqfCT|`gsq^H%J z+aumLerzkA=b_}R!IP=nchD>xZjvc$mDwX3*F@KKe^tghiUsMPNyBmE+e!KDKRXVv zy^tMDS5sC88$c&~0Bit)%*PRRW;1(Qi={?Sdnx?UqC~G#io{uV4qhoP=iuOO2_ww= z7)>L*y|1k+g?0bw$X#&Eq{Ce4X9gLE&Y!MDoLl58@P4Xg2p)3V@FQKnzY^L&!3%kz z(s)6b3;h0r>-%UP=Ge8{unXlhjp)%{>Tn+7IrdnuB5>G$qgV*#%(qDVxWwh|F_MEo zeetN?j;a5{sXrqA{t5ASH3jL_46#G* zV~+uqv>ZVWopsEBq=}uHzUYZ)a(-SKLVvh)T=49=%oyqgbDf%#O(@vHb{><)iPQ1N z(mM?uZe<+`IB^l-{g)-^{T%~a&fF#*}3en9%Pkf^?`{_0W{S0VF|G+tE{2 zKPTjW!bMF(F`jFgBkb)0A6%?@mqd|ioEe*oMZ;AG{mG&{omS0pVICS8z1%ZDiGJ4KBR!J@_U!Qf8sTSrC0crC-`a}L z!<~I=W%q}CAKtT$pFq5}JjMqutH4UHf32PFKEu6=8r zV`&+Ow{u_O=QkNkp($;bv1ERquKe@xp8Lg+|HZJjUuRnyki84qR8yb0bRAN6N~P_E zi>9dHbzvTyMP*jxa9nn~StFNcvat(g-*MEjc7Ktbp+pLT_oSmyKn{~Xg7rGQ`~ zxYgdi2kLnHXCm36l7jON`*$b1PG|iV)*Nl2@H>hN1OklsO)(qTHzA2|l#&R}x$Y4i z8QlJ9#Grobg{}}++IGDFvC}$I)P5uW%L1n+>g7)(asu(TZHo~xTxe^ew;hIDxyK*k zI}6-3Q4PX3^JAc1EslX0ms{q!jsechnJamvt~8#H>szwn|4_SJ*}RZ%g`AF_+8CHL z5?@W2OYY;%*A6(xM-iSv!-Mg8R2U!UopN$%FK4&C(@DV^8+H9O8ui5mEi>F(<~)i5 zKXzj5wdDxooL7Sv`nG# z84VjKwPQWjyI@RiL4uIx6#tpgbLy`Wu#kxoeV3R=SYtw*$CeRXV$xr2x@&Ez8{V>2 zszIk>*ABl$SOfgLHLgyZ$a1-?LWLGGcq}fMOA`B>b3Tjfo#vQx3=M1yNB+_=>`Kx5 zna$K$W5jT*Uw8wM$t5xhh02n-=Nv=y8IxfQMg88A>qxOLMp2DsbJbXvc(Jug8ZTN`r`_v5maAOG@@qDhJpYpX72+C0=1L}86%r)VlqJwN^o;X3NVEdZ z(`sgkNN7N%Ax#$(9L<+#9tTur@ zW&@a`Dr`Hv+xEt(uAz~q2yWT8MRxlQ65w&`r2CvGGb9}!^IgWpNJt{ zg3$%$S=v*XTG`xdBzFrP75(H86KdgvhuM7zD;a+vxD%WhkekjJ6KlcX1da!)!h36 z67z8UDbwYuE-%+#cP?ZtLYUBQO~Hn}iz}US*dhOqwx~IFhCiFSK4Wn<&!+8*RPzdQNRnSmM_{>R&OpqCAo<-io@1f{CB`Bm+mx zdD#NLYK;V0=_G7AN`4adZ7qA7W?>OwDBxKkdr4{EC;%)?ny2Ua%V844IlcB}A6SQq z=daT{H1rNz49?^j&$;>=mL>X@V{U-~vlYv^6qX~SlG9X&Dhon}M2OzG?zB{Qmpf=^ z!jQ6g1EYp{Bhe}r@cdhht&noHdNV|3l;%k@w~Jqv8bl-f*q*S>TMW9FIW~$ie+rrU zD7dnGs`eRlsAHtEZH!cA9^^oBP)GqI;XR9N73p2c3PS!Cj%2bNmYWPvd;sZSBnGj4 zqxrO5P;}|fmdas7Cl?z0fbAXCkrMEcwG0+x zB7*C^?(-x}y4^x#aG*iynbzRO^u#=VDrJt!q02x)bO@d-pe4+jsakg)n4ZY{-Q;VC z>(7a&8yKEmkJqH@?^ojKkkvx@AdcZ&OWn?Un2u&07mhO&=z!mp1Q|Zh!u-~0INxd+ zpT}^+mcu0Ht;S=)ZuG}PE+0Rx=M5oTQ^})QqR3|&a;B7T;9y#F{{4&C$ME=$&cJMU3MG_VXR zSv;Q!QsAPx(oy57VW6Nu-?>9SMdn$%9&bw4aXDb6yw7S49ZX2CvBZSbs<|+{$ zFvI`8!Qaw#_Y1>`e-lmfgrC_Hq5O^{KD7gy^&_FbK_YHhkA|aOqA{0XOv?!z>m5c>)seU z#=E*T?^NVSWFmBD$z-KcCo^e&uE+5A0@v2T;F!iRCHUQLJ%+EC+P>>#J%&vy5tA?l z$bALoE`SN&V|e`dU)^I^JOd$4UMXTpJeJ7Y0}qUaD@Vssi+dM~3_)$x0MsF$ldYIy z2tLiLLmfZqLLly(yxonKQ!S@4y7hNBO2l}@2$YC*`3_z$;+EeLhjSPA)8Cv&nfdE^ zlyGAyb@Ea{`}7`b^+o=)$Ux-p9XA#eMEG#)bP?;u^k(z8%X{$x-2*Y_>tI_sHRIp} z@O);0pZRhiahC-~(U1A9)BR9k7D)X!4y8+Ql@l)e3Iz`0_{ZR};1@iAhg^}&)js`3 z@dQJh$jEgmkGw@n-c{SD+ZcqAU~g$lM2&#%_*%22e61hzk4rf04qJ5V&kGs@@m=^@ zVlMAi_gJW_yeCxQsGtl>H(=3q;jFvfUuh1`$*r(Vru!Q!-rrxZpSoxXx*sr|fM2ek zI<*`9RHmuwE}-i4e-H3`6pu6N<0DT^>Pb7^-9HLkyO1sscsC=$@;6mVD%4CeF&@s~iWd+Wuyh_=e9N=kJ&jmX3Ewn|(F z;_Cso(nR&66IhzRPqL0Q_+H!x7XJ%-+HatVdJ)W=%$3KYS!o8dx#D&FB2833UK6!J zavdUv;AcKB2rkC+Vy8??DX;@4V|=!1C`#{BSfpEDKgnRjxR^A~oR6qX$nPsq3w0ZR z@pVyw1C!sGUlR32*?B*lUne|M6lA;P=L7l*tQ815=pMEclj zJrJZdr}n85cyUGTIXL-D&b)JHOuF9R(>Q|~he>o7HjZ@En0+5UjggER<51_TRst(# z+2+MlkDD@4AHA5YU6%!JN}j^f{9YOS-OBK@nld39{r&K3F&(!60uhO^x}G zuqdi`HSJBp>a$Phl*36o+2F37e3o4guYF8={m=D(I&sxD<@s*?n((0g4pZPq4x1YFWKsAwQorVpmOS5Yn*y%qkI3U zlMrocZ4&xVad)pR7W+@>`oBz7?~eXcnf>FCP?EMo>c-Q_@haY17r;K9% zsaV^7%kieLngZ*+GF0EsfBlicq~36(i8Z0(JkUJ~Nxy@Y9G)EidNBUjw*6TdkPK@2 zVx&e>twy2wW#18nvBmdiZ_Y*QUB9aMzPhq2iqXnz$SrnuYFv6t#oMKw(}C?LPf(lRuhJ<$S5@>-yD07#EyAqe_lwT8;(l>I)`jQ~ zlM^hgmpWQ6_rTaNdn<_)+YZcONK3&Nwi`n;iRMs2C?H* zh>oLyRR-E!&6wiW?#j_btJ|hmbbPNu_FGd%Q{2y+myQ)6o>qfQm^-19x-!FIMke| z{;E0s_NX8wrHyM_xhUpS43vDI0*^)f=nt2OIYi$pHf8#mUR%dsI56>_=(QCDyZdW< zZBfuF%*Cha9LN3tb5YuW&3z_H_5tx;3iHv~<4ga%;F$@=-n6It9$#XwFTee6J;8YU zZ{ho}Ww`xrlwHgx>mMI1vwruKz}aYj;p`;e1VD%@rtqA;{wNow~cO7cV=t^8_VQT;iEL~lIvo%Uydu% z&6LU1d8{9odX!0Q_|<+><;kJ9PT&hb^&4MG90BOx($Cq&YuQUlDbKOqU(N4t5qp0X ztoI6xDlaY%>F_MHF|tC?8klen5=0(9#vj?Os#dKTdo_8vvcqd}ib@rT^3jf|3$|3z zd*B;=KFj`&NmZiS&@yEy(zNP7eSA9158bQkWFOgiAu4M=T2`Hvw76<`$)dg@8z4j= z+Wi&#d*`DaR%?INOAjiV@)J3%_yV=qc%ne965Eh{H`MY~Bien@08=#jeZip_q3Y0} zWo@g!S9kh;f-Gy40`d>f9~vUv<3KFMJF+7{Pg~?FvU*J2Q7(;wPUwa z(=4c+tI9P&H(xMKJx*6(FTYxMhJ{Pk$8ZH-ORk^=4Zs>JhM>$M(5K(3h5mx#8!4|}j#tv1ZT&XHM1+H0@-ETQO2p?h3eJ<$Fn?P5dY3U5;?>zWj_6;E#$#ce3-FNJF8k-knZmWwxGan` zw4c%B1Y*wQX*=Y+e~H^oZO0tm3Jw4_yo-B}o@^881^DOi7`poBl)}$)>D4CQU(wsT zWv@2F1k!FGK&`}@p7RPNJ;vc!isoHm6O%G~)^G8}7zQZjGhagF z_vLee3fU?@uH+15T%`NExHpLXdic8<=Xckic>!uyhu_gY#L>jZ(Rf9Oe}$g34)M+X z=v7NX*5dbwzk7OK`23my)P@1}CX-hYY@}d9zl^q%j0ZT33K9G+Tz^e-R>2`q4fB-g z@Dyfhpn{wGBqe^QgCsFTL}!`@hP+7{=@}Ew#ZeXa+cyPP$p%Twm+SXa%a^{ROw{tF zdTl!n(oA*s&GFR`7akP9FTZtm)#+H(Td(VjSe}m1A3bG>bTNnQ`+wQLS47^ z{fwmze#$|~2Uj-_@eI_O_1O@!%=0t`NZU33agtKszma-69vf9eX6;<~O^=G|v%7X( zpOivI_IFFZBeoBu6CdvF5!B>+A+wk}9$$^ZwvzaLH}U4RZmjkPh z;VfvSs0){--Dr+a!%C6QiZ0xDZh*2m{y0X?f9{CFUFQa<1k9mfK!X3nm`xq}uT)?K z#tSIkh~{AjdI@j2;{T@q6S_yxFH-9nP*gT4jxT%*Ryo})h*#RuZ%(Q^5-r=fzcIXQ zvj?X)JovXW{Z`q=t*r02_=_^e_(7mr?d7*iLPjBvh zxFmG)mY6lcu}8_#~S~nYsoqcM}tc z`-srnl{$P{RVT1)^bFjpS0gexYKt98kx3*UnIu*v4qA%;@N0d^l(r&c9W3 zxm#KV_d$Rg#rAn3B=e*Jkc`3Kj~nvWx*J2ap>c6>TL<{eG8O%DR~g&B&oRkx#g2rY8JjcgnKqo*6!zF0dS#8Oq=B$X4h`!-(0*CZ&rbv ztI6{mGeG|QiR!{7zt2D;@o{mRwFCvJ)wZvM;no zqsOSgQ1mw}ZU^;Q|9rpL5JR(7##KWR*+*{6+Sz<(|Cg`MGIpL%Sp)+SrZGRU$xEw! zmf<_`B*B=dI%4KhRoVbSHBqy0#oYsli+!8Ye4LA`5tc{E?9Ov!MVgozi}{F+Q~OlP zb)XPyRC&RQJ2kODQskT(%yZ%ERTZ2DyJi@QI}fT_)R>V=GkeL%HTMr}@bWa5avDV` zrZ@-zv{?W(?Nz46qh9aGtV-8@ST4GVg=}u}xOSp*9xlg2uJiv3e$Xwa|5SQa(gt^` zWIc3Q2ab${(4Q6j>|)kCf>pYsINF~1v^O#mQf~>hC%~B-ylXPr&yJ8_)7?&;HPYG`3o{i|@Y{s}_ z$@E0L)Txbk#gg%wh$W*jsRT=o?ao&PBF6V~#RK#xndZt5`=bz-h}m2gEASps`0o}Z z9(g_dqyBvoN&U;id^wYQ#e)k|$7XJMgF0ArpFiev^yon}K$?frEfC|@*B*G&q|PZ` z@NkQ*BbXF>N3=z?<5(sQ$7SHRl)rpg(&Lo!t^8OU2-f13;im^1o*-=tyD)cgZb`v{ zd05nwllrx|egtLl7v`)hpYqXjGgj(y{;{Hhj7Pj7T!;ih_QP6 z%!uicl@)KE3q=dbBgSpV`jhwm5*+(|XLtJ_dG3n$+fwHsUB_+rPJ}lS?P$%N>9cQA z;6X+5(6P%NpE9808GW!1pS<@{^yL!O9zh3vYq{1@ibU-~wSr*9ZezhdcwWq@6V5l2 zs~TH)ab8At^$h$c$DSTh$Tk#2^u!<4BmN*5#=I>h*b}+{CJo1Vvtythe3eTKZN+_K z+0@8F^E4aYW70VLOo{Ie5Sepfj@tW7tGBl&;21{zeljF4oElBhXQdcuFOK6%y}V|8 znccYh9@Dj2BmVog*7maTaj!he2RhE%$$K!8LGVMztVDfe@XfV5>N%^Q2b?CY=Dklx zdW0RX*P+k5U#P-{k9T{nLf%wzUA5D!z?h(9CC1XZ`S-`5|s&;=L*E zAuiP?GCS^yJzcgka$d1gb}~~l1~MFMtio;&6mYJj*C&OR%S{>%-TJyeR+`rn3*c_k zdlc5!WMSaxtH6iFp3lZ5M&m)z{zT5+#HDz7K=F)fY0P;m zwdf{5J2$tXqgGe(O{iB(PDWLQhi(-AU9^_jb@Hl;4ENFL^MDF@p2lRpmTgT!Qe96S z#NPjw(uCnXf^BuH{r;I8a5`(fKE||Q0XmAvkuL*a@%?A^*a1NWIl{pgKXYK<;=*nBaUw9VT~2oF5wy*}g9O%XxI zhj5lqFKu4`Xh&=y&+gW?2;4!bZ(ZT+VVoo22Ycb$b{GHiH~{7+OM&Y(3Z3Uw&GJ%} z{)9E7pDQT&^^h>d>b8l0*4Z*nvCn>sTwP=x7D^vu*29ExNH%#!=?*Q+l4Nzo?| zR7V}_g9u7zwg|D}4_VuJgxg5*=z2bMd z=lla}y3P4N^1sjdF9;QL{`u#x)Jt;y)@dGV{$)A;bGUAi!yw7|D`LzQQ7c~7L}V&P z24z;tsoZ=Qr+TL0sV~hw3tmtxc%eo8fA^qv&&>HF<%sGdA{;2da(o+h zVOQ^x_kWt@{m-$ye=*DZ_jk?vZ;|Hxjc$4WCglAmv%J54#wTaaujGoFs`fo3=KXEc zE}_x^VVy@(3WF{`rVlw?=`CgpK#8_ib#+Dir6_f&lBvJ z)EO7ER!%9dG*iQlzu<5JNHe3_sr6ht`vgV7G(nyh+qWdEd|^8Y>M@By|dAPSJExB5q|@YiT!rJQ{O-#CQqs*@XH zVcd|r|Nr^1ptPXJlssmKbZ&@w5MhoubMk&WU32no94o=+JoKdymkRkA(dYbufI>e> zzU8_|@Dg(LEpHQ02m^opAh1O;_~J+T-w1Knkr_9f_v6xT-^6EHn(IOy46MniIUb*i zN#?K4E!c(oIREm$b{I>084Lk8Db6yIIoE$@`>IP zm^gPf7kNy*iSn3Nhn}CVt7D0GeY-_Wye~-dLP-+jk{ivOau^q0x$`ZYOg}ZZoKITk zSB?@G0J|o?pUJ^d(?3K<`)cTgFA1BQujT|a-B$ZX?*Y%0vo9$B@UZv=#U8yVv#$^B z@O+5R>}xl``kEu)O~;K)UFECv-8}Yc#&YF1pD*62Cu3ciI^$?M|@RJ{Z#xnc1@{g|wnf(Wme0fKbd{H1TZmt-Jp(JjxcE9|!-i6xq4wuaSGDmt~ znKM1`-Ow#x*^$||3xxfJg>SYEu!qJkYuog_y85Xr8I`R*%0a4{ohi}2va`tSw+Na2 z9SeN^$1St}HL~w}Gb#K2ka_GbmUPnW@~B8nI=`3Of0U9=7n;A^CuH`2hb#C_as`3N z#kU+8+Uh?h2bulLl-bXeWcF*K!xV=)=-7{{#~pCN@U_#EtuNweX_Cyo1xM?sh{ny@ zts93)(J7A1&Z;p75|IcPc7Dp&F8gH+#&Gn zkv<^VW3u@@Mq)pQ0YU${6Z}Z(rnfX29rni{K3{zTAXqjTe*qby?EXn=erS&-> z$&VEk?#i^e#-E#|Yot+JBaOSuoohtIsao9Lo7PKu>?MUZw_{tLl^(l8JocNrP0nKz zhAZNfw3gw2&@=?jx7guB0iP^Sj|^5`K&?G>bo0Bbbwp}CSJaD3%*;`*2W(7fPLG6< zGo!FC@Z-@Jzs2Jc{weUrRm6p$e{p^fIgXF}rO$}`=uW1G4(mBlr9O-Nmj>C_ilb42 z7r$%9ohuZ4-+J-BD7H$kPq$vgMVA$>!AQ8?7x(w3d5wNl!1$VGEU-8*zT5CQ!rfY2 zj$OPy?Th2WeWaR`=92;0K?I+&dwG?8Mw;ssa<}LCTqofJyj^Qy^_@%peQULQT2#;Z zqKri`ESn**dt%Nsj8{F*5NG_Ya;7AEiS()nm^yN%BE2z&Tq4B~2lrjbrHVu+MG{4} z2Qn18HK~z*2vDV+KA+L&M5Q_|hH98lMOXe@NPJ+9ZN^5;YQtm6Ar+hJH~D#NC&=!; z*~RC=+Bf~qwb^hs;@44Yhq5=zx4woq6JA|CS3d>8Z^^a~KD^_c`bNgvYa&(n-Z1oY zy5pSohc);+5dIYY27*dLQTo$9505os_ubrHP1Fwb-uRom!f1cNbFJ4jEy}u}5ZPG4 zUEy?%ZMKz{W#gVb2xPDrbtLAgYvX-l51&ZSGcwj>;p?oRReOHsf(<&ZDtCGJAKO zGxh>C1>;?&8M_U6R_Hq2I2GSf{>csUw`zM+HO*tzUJBh~=1n5bo-ph@^9JEoao1&e zh>rd=8Rvg_pAm&7MY?u9rD|m#>1CSIUY=%XoKkNOWr_}zMkTmxIb68LgHywl-=UD{ zeg_Hu17Ud7yU*APBu@991z~8`Hw%O z!;X#P)D?p&>)wPm#%r|Q>^{%Z+6yc9VtQt_=t~ zDty#6W@Dh38>IxkUA(elE`;*1dcL_0%%|Zm${SDgC59EB9>{w} zEss%FB6p(#V#XHInszLtD}R!`w_^B}&_^>{Qi?QVWciZeAUbBm5eqM_@#@PqP- zofrcy*Wiq z_?}CNcX;g2dPAnVaBLAWQgd+9#bN6sQLiWS{uDD*kZ)H(=e2Bu2Sn{sv{#7%nG7!RZ@T z8CN~v9k1Ngo6{ZVQbDY%3;{Wsk=$1O!L0ezu>8Km1!l!j&)+v4RJ;wn!Sa?tV-BjU zff$$HYkVk{JuJI|_*Oqk8sCz19-q6tqSuO{XUn|d{>!1}x9q9$jk2rOGeU}NU*V0K z0X#u)M#G+CcOWP1No3EVrfQjW zndaQ9l^4V2Y<(wqau6|IAO>7{(Ud>n-QdYlFg^Gi!eN^~Zx2=*UQ)*Qy6^TB(*_$% z)&sJBa%7sWRK6FC4n$zi@qDn`CJySG=N(@{mP#`dw3p0sDj=FGEg-^L@6LV^Z&!?$ zhTyT_SES=1Hw-p~w-3Appq?eA%ZiI~vx;&}d1FuV6N$R>Re3 zIBkZ=ctFF&jBG7MPt(x|)}FWWH<9$8!^P%Qw-CZM}XLYGZm*lrZTf+awLYE&m z(?SnYSV5Bt_i1`6NOK6guzFJ2BxSP+@wFOCD2(Eid7io&e7s5HM`=%HhbiV1$CJKS zh(CwX>wEAc9nW7sG}H}-{-u<;;*$dBm(Mzte;U4ZKI;i1EGFGh{pHqMYEkw`p{myvJu_v^$44Z>5(8BWKVS!|q zNp8P*{VK1PZm;z^yVf~uk0f3KVWXT(7FK8u(rr>(gJip8W4SvyMoA%DlwuiSJup7X z!}z<0{nBOD7hvYPZFQ3CaNp~8xb1bq-gTHZ9x47O;Dcf=THLs#Icd=&2K3?qULdhG zgUG4MNZ}rpQImr@4YzB^$($D3F50JN4x07prd)LeEK2nrt}dd{VY(lV(7<$Gz2B%T z@md(g$#V{ewcjrXt?sEX)I#zm`SWLX!6Y{((7PMBcJ!KAs`&{F-h)8;~p8~@p16!f!;rhSkpQ!D%1g+-%^~U?PY@XN0WO0 zap4u~7>jY6Zv|%qtAf8M-vDctK0pz z>6)pGhZGPyZ%%{Y2c2hQ&VIuk3Ye|s&RQJ$Kx5lm{x)^S0u(J7&i(z$;2Ike?tiy& zMLsMbChoT~VqJvA*l&LQxRn?CWDhQ*9d>iee4V-`a>mF9PV}iD(bfmTsKXMg6ED3w z-+Kn8i3`_z2KFkR>pes1q#(52OFPm_$f@-!BriI;aD_}4Yvk;!zSa4>wtgJ8MGeJ5 z`rBTmo7eBG91KhQP@sZ)87eqJiVAjTw@4L6v|I6xb!wQ8huku^ed~W=XQ|wTcCncF ztSoYgK_n?Ll`_hSQ`gAlNw@aFaFn4=Ku2)x0*VwctOUA%CMTms>ePa%^hTV!)7~8t z?1DpmMC?x1{JDa6Z!d3WzA1v6a)wi}emqJqnYw;V+6x<#bm%0LEMfRG{w+!8bt)Va zh!_c1#yxaWkFFt?Dcs!`^7k1k{h-+8t<0PJ_rFZYEs0y!^Kl?8Z$|8m9HMN-l~T;%~4T<(i4wcxF@$+h=;Gn zR-^IN(wNd%5(iKi%V<30_Tz_*r6lJ(DkrzpR8SP-zInzMEivU#vu&{;J3Dz+QRe6@ zfw`51hQcI4C0Q%`g|*TmEC`F0aR|XhIx-_NT-a&QqfXdqVsG;d0al<$gTYrM>W<4a z%WqT3AWh?`GnWq6Dnv$MP`h%=Aj( zzNekNo+ueE&UFtwX8QW`p28!3j>8EM?y)7Go_pf|rS}+(muUl{+x$!Jv)lb{H5?kv zmYuVGu_#3vAaaj{22=qDR*3EJY^o~*R;s(#H}J8|VYc1#{5PM}iqy)1zHdDlYupF{sx>Oi z!to)$?~8uNLNVF+kmVzh6`!r6Su<;tOn6>4A!K>-X@6zTG*Mi(nVx~q){9z)UEAJ# z@4(z0gU@Z0Ycr(%*4*@F8!&eQ6ujOnkKIi&gMaCQ-Hmn3H3N$^U;OvYwHWQP#RU&7 z%grh-C2-K)v*E1=p1*|*ZbDWXLV9w3c;AOjJ;~e?xe;Qs>ja_pv}g*CeEnj zSIr{_IsNF4it0f6yZ3+LZ%z889qV)gE&5)a*_8n`$0CmJcpYQ0|=eh_}Me)G^Cr zg*6+62R^Ujt5A}>^R4HqRvH(U=CzxZ$EpZ}FT9Q0W;WF2MpYX>HWtsjlS>I8IB1uH z1nlGRz#ohM#~xLl_Zq=INmuO+Q#7}rl>X-eNy@$w9y80endJnnTM~sDnswmwG zoz(RS-hNxx=YUdCdFHho=@>1#M^P#rqun${D`|{w?s@1Qp2ghV{o->9*zexvx%y%s z;{YLIz?oFCojH?vM{0#G=?k_qd(ciSe8Kg*D`^KbX~h2Fzw&q!(2n?cwaSm|cwjuh z=El|f5BkW^GZ|lR&~bQu#fe(gfavvjo$7pTe`y)gi|U>E*O3IJ?;gRi`_KGz+IvM^ z8$3j=_rJv0=x$+WcWx}A@4@-b+EluSDI*(rb!Rl56uz=)v)35U0&rg>T$UEJG1sPl za>Qd@>=5dnEy%Op+!k|hs(tsj)_rSEs<*F9d;4gTJvJI?!d;YG`}?)8)JRcNQVB`f z80=y)wC^@)IKW8G`AheO_XRDXc*rfr&o9Q2rWTYzhCpH)1-yvI`t;Kxw?+y54Ta*3 zEmM2yZ|H^Z?XCtyl1j${kLPk>4F9RUvp>5ekB8BQg=0S@NOXZ zkc_%JsCdK|EY8V&Bx`9dcCp0^a?>VdEYc&h0H z5H8d+mQ$_bW1v~Uo#>{XvH5O&pA$!GcwtTQjGqq~7Kj=PDlH+@c7i})ODsi`yk$bk@3RE<4(@-6v_QZ2q)Zs1JQ)IT=D)(<2N@I#^1c| z5oM38&cQTBSsmjR*F5w5%O{S~-Gm%2#DXI*$AjDy0ex<4;8Pqj8r{uur&5!h$HtJ%tu z$tH~xFLCFjh+J?|3K92GTI>9}HVnr@?f`zId+GlIE1S;LHt|2#dm!qOh&YzC{uCo# z!Lk+lu#)#cpkCYcolv-{R0d05B`DYq}TLY z#oE-07V|ODHI5SSn+#{X{G{NkHf$5UCkM~Wa4FmnKZW|O0Yg?RWx;D{oBRgbWar9b zSqLmvynz+}L%nRaX9T?z^f_KCUU}?)LS;kPTY1r2!(E;bM_GMx7bUWgBAe`hjQ|Cu z>!%(`Iu|>f(gSiC)Xc|^xJ26WZRRJ5N0o8q^clVuc$iO@3>dUs;jKZE|v zNX0}Rrg$uNW8cIHn@)L^PyO5*zL(f9!d>Ma{PVp64&X}55PY*%!!>@sV`iqFY@nGr zMgie_^R6`~VUNp`;3F&Keq0!v$E4`o`Ii;rJp);8rZt10y2%3GDSI>ItApx;iX%dT z^V`B*Z=*q-0c%DZ$cy|WM!%Zh+4lyN9T;j?p=*r|%HZXGLeo=29*hvASv32P{av@b zq_-aJsp6Gm$~6_yHwv4kiu%!-{Z&6?oYSE8`$YEslpo^tpB$;IjZ5H{4pt^DH#6Qd z=b+-Gkj;rGxHfZCy2gbRK1ZY$7#(Hd=KU!@<{wnF372rQ@ch%G((NE--|1Bak)ogr z+iLC`F#1%dfneQnn2})x7oHiNooNYx-`O7U*8nX3L2$2a`;YxNhfXVUR5pKFt^PV8 zX;j;wpPdbYdem}Hv;EItTUQ24^D2Zj+;7?a+$*X)&FOO+^nJn~qv_84SD_}9*;m>q zggt{wiMWJ+*IZ`nnh=N41&d2_7nYcc_}&Gk#ieQ4JXgSV@A*m8VL2s4M9!`oi3|aR zCY$%#^*yZf-ndrA-F!ocGMt}w;)hE%S((*f4BpPd^G`YPLrNluw(%}J=EqRM{HdIO z%NWLt$uaFFY0ZaP<{)LaZ_zk7`{>YDpBks6%8=5nb(nfc7 za$a=5l|)Kk3jg15k?sIgB4A>V$epR@447*CE)sg5m-!O z5iV)%+1A_nUM;kGOj8fdgquwn(;o}ZpRxXF_9tgHuC(P$a>C2_`(jRp6J7?1a|>Lp z#CPojKARJPZVKI9qfv5=F?cN8;|K8Y-_>^o#qqx$>ZjnyxnDZ^4vFhV|DBL?bjNy; z!ewbk71EAp$9VhIuD@{tiKIAa`~PVO(dGAD9E;%O>?92Q;DV;!CQ=RZQ*#5pUT2?H zoqAxQnhfLwI( z6*eueFICvIj_PB>1vhl~cum9%M~fq2t$9C(uVw#C8fT5Yxa#@yl&=+7 zZR5gosYf+e{!*fx|9LK?=FEe*b$mcXf)K(fFb9sr0UjT|sK2G7-1pRC{gJDx(N-yO%P0`6b zf_}WKk0*f@o60dqo3)%py4(t>Y4#;tXC|&w5x6hC?Wb=WcV(O;`4(*BDn;Yu9&43o zzb4;Daa>sET~Tc}EZM^tNm*Vemb_+P%s2;@%-8Sy%H!ec1S}a>m#E|Lx5tS!s=m=A z3yQx5tXQ;P&JiS@i9G@KOBk$OQ$)LPi}%LRz(zdS;CQc67z6j?rairdYIjI}g3bF| zzwbxK`%2jHrnuM(iW})4aVBW)4YNENOSa3IOm*M}rniN-O3c34`ScjVrh3Nz38y@& zQb`-JXu3yFZF-1`X<@$Nu{B&!hZC-#ZH_L7GjtdbcJmz}3zF?M!O8*r&K-RaJNKW5 zV(0#0yJ>cdx;0icQRnknc<`Z9U&DkLz4G{e%Qo~|MtkJPq6Q1CgEQksCZR!ZaON45 z{O+O}3e`6D;s{gO2An~;j;notZX%HNALsSfzkLJo-$hTb?-24tH#qDISM&tg7o>D! zsh@nf_m%Bi!ad4fL$hD~`&M5^4p>u3-w-&+12!vvV|qTC=n!zP>qQA zzbgY`yL-;}o&P)6b*|IPx>j6SEAM)zXTEPKhr>rl=Nhqe$3}Wp9yK5^*^U#3oiSVX zo_{#+3GMP7cw`21vo|}P(6|rx=(hD;PbIygUcOeL7t3AUBZ+35e9S2RCu7hnD$IIk zPa(aF%|vh7;PnNfR*u7$Aj(YF-W~T%l!w52*)*1(T1!Lku07ure&VGt>M!N2M1u#D zlm3MWpgtJRj_grk6^T@habjlt2-Mld?BHpm#&>o1>eEi1=%Ic|-Z)F{{($R}5)jOm z=x{ULnx39b$x1jQ-=;^r@JvxT3-9rPl+%+PNtg6lQef$72|XOK!#BWpiv*1~S@P_J z^&h?FB%?R6$(p?t@)>frG51MU6uonUL_g9nWFHzx=w)O@qFV$eoH4JJVzv8`BE)9n zqjvX+Vx^XA9EUi^#8q#{uEFj(VXv-9H;=P(^F(FLNcy4Hu#BXgL*{V4mb<6!+bA1> zd`p@;+0$xPu|ch#F85=biEnVR$0PDAmz1@lOwY0L_zl-Tm)D^UdI&q6*&ar}(fhR> zF5XAyJe>XMqRoTHzSn&oy6j9BCpi0^b4U;Q^L^!|j)?+*E*;a$3<9FSsbjwN@O`Ha z>B%cg?kx!Z*NL&g!`^nOo58HQ87xL`j_f~kjZT1cQ>4M~LxUN$Vlk_uU!Be2p~T;8 z`asN^t5~You8G9?U@#k5LtDh1q*OfuCUq`9R0vai@MiJ49xIFW-!8hlY|e?P3A4Ss zOaMdbS4(pHq0sekWP!PLe=>5>-_SYxU%ZsV`8zs#@P*j%@?Z*nApV0LbJ}Cal)G{# z5$&>v_GyG$(0OVFQOdzk9#SE8uzPE~A1?p&`a3^#7q5v(y!PIT#H)3|_?Uj(az);r z#o9mv7QeKCf=3}ByU;1y;EDMTR8_1X83`RE4=d(Rq^#he@>0-1}#n{(hqa|WJ zt=l$Bg7B}LI^2!Znt`fnle63-eYkZl0(*1j9OyrNyL4UUEGl&B*X-K2W&@xE zfjqQ9XuEi3;7#Gdod|4ZC67~_&(?@Ua;En3?x*{J&H)MAcQJXd>fEeN>(S}nM(1w( zmYs5(N9cc-PWOkH;QyiefX}}ehYCSn+NtiE0N2)E74hEcx1F)jKdA%p?AM+OQ;-xQbj^Ee!c}8t|LPvz&{aw%VfB)T(uDWVxt#47!tUo^g z-_%w+Jxa+5kGh`Epx;4b;glWhSp83Gt6zgV967BKeDwgKX|qmB>1NXA$*u6TbKEM| zly~(5vpD2Q_nPG3)jc!**v>!1nB4x$9}{d{?L=ysOD_H{mi0=F^w{M8dX02a@2(o@ z-<-b@(IrPc`2iy~h|v|7KE>`4Ze2Zu{kMK-!~c`{`a8U^{~eCGZcIe~eVlW@=X1Nd z&Ry8-DgQ7U+$D~lGNvH|+~&lqzWA>1JE07bKIStX`P=ipcS3wAS;f)+b+%N5{|Wog z!^E7xhDF*BvJ|B7tM6Y0jGl%7qm3m9sE|aqV2%fY()vxoMK0RU{iK|Aw|r{!!PCdQ ziv3qJpdUWv7gYH7yzbP?T8D~~;!&uEBc8zJy0LE|@%%c&`9_qFGH&A;r=V%LrBz%} zjE(!~o3X)OQuGA`Ad~Ht`7TZpz(`nTq!cad5wGic{R7%-R`%GpGT#<@T`Cb0Y&9?* z$kvf~i=%qDxMocCm!eQ%Z~^-$;TZN8Fm&xTgjVhJ3~uyaJWifyb^YSUKeE4wJn5+1 zq9JJe2>cN#%70Wa98X)!!t47Zhl${AFh>3_*VpBUqQ%*!;LAuCI9iDBM&D$A%kce3M0Ps{ zRWqAYav8QFWD#CXv8by~-h}=o?~0@RT<>O#yp7%s)lIXZyWJB~MP5sDoV}6VR?VWp z2%LIPe`jl}$Dq~@3YBlMYRxDClgFwhgLdKJ3%rj^S~SaBu6V;WhMQ0Y+-uz`;NB0T ztA^OT&mZaN*JHRQ;y?UeffAoKmD|rj#7ZZoC^n3m&+0(D9 zrCvz1O}$_({<%laSKsuLk}jF^Dz;fUTC0D-zjUr`3Z1icT5%e$*BBP;!C9fD9q%DQ z{6OrP@E$OLKRbGW)ZGAho(0j-+f_{A`RptJMg^*RS%DITHoc^?8Mif$ z`SNoFZsYsGP!~duvmj?fB)ZAoAgFiQIz3*8dc(_`HlUlPTQtF+v77^2zT8?p{Djnr zFg_WLiWJ47Ty;_RLZeWL(ju>u%`4=MV%`{ zHkWt*dQ_pblf~+F!_&7+;`TG;jzlyFa_m5HFI1J*W2k>8n|`^JxYGNARCkNhhZ!fK zmd$GJjrjAfPD5U@98nvv>5?Co7a?j2P4{vojm%T7gw8z4lDT_wKe>h=_%^ZC%wlul zH(mjAK1O+>c4P*!7UZL;$ktrv*2FFhd4nrMgcr0=Z{LexL#XrXFcxLiA@^uf?38xu z4s1O9Re2rCUP3mWhYQX#Cp~j`T-lq>`gBCqNwd50QD-nCj*;JM9Sg(!SXb#gPWpxH zVDfjwa06V#aI5MN+_F@_?T5C3!YUh?T@2q!Mjm&J*T!d?ZL&Jmet4l7?h+%vD%dEkT5V>s;E{m;qRpHPY` za`t&@JY2zOl$`b9)E|>v@N3_F^N-~35E14}ea|E0JV!rwKJf4R(SsZCJ506T*G^V% za|_Sk*JOII);!O3?-_t_fmxunuKP-kxiE1z4Pu2ZTXso&6vvLz*K!Uj$@|ih$0A#3 zz1Xol*TdgO}M#6ADqZc>a(3;&|RyqFV2qzz!E}}=29zQ~S4S&^UPvyK5w=7uV z-Pqf=rPnkXv0Ng>-^tsuaWdj<$%)r{FNy2Ny;0?n|~o##@LDLGS}C8u8jKIX#}_NRdb% zPJ6>S4ku3lc-=5*2&#|VjS_T%xt9l>UVMac)W3J7O4(sctz*$rfe6r_|YHG8m5Mdzyy^(g$W`5vCS#^JRa)LHyKuQPf>eN@R8oRC!|U3I@e`A+?MY*3xA*7N=c-q}?>q|SGV=kxxX>&Kz%I?v~a11xP){x1BV@?FlZ z=(zz^B{`#MsFOY()pTS~aL+nlgV#+|t-4E)Xd++UXl*M;H%>?XO!5al%C;En4?{13 zsEhuXO=SCby3Xeub|3DJ_2lAeNB@lEglC`o_eZqDlYLFyL7KV3aBI zDf;Xxd%iQ^Go)@Su6QG6(RassF-YiHKW{G|fadRP51UYa+i%1hd#t?kapbXqy} z8>ftREnw~h?%&LtIn#q)mJM(G?A<(A=`1dALY+^tP0H6GOQ8J?iT8^99z5V6?_|_6 z4szhGW9u1Qa3DXuI|xbd8cs>_3na`w_}Ha8xu_yHgnk{IgzSZZFA3leA$uXtUhj*j z6OIq6DxBhFdDKl2-4RM>OY#u$7AA4bciI!kITSDDa73uzoH@>J^T#b&5z5j_-U25w zP=ibJmJWN4{Bk&k(zc!VXFBh9`O*k<&WgZE*WR7-4=2w;&Z>tf;gFSkY!ZXpwj6>^ zIeXCm|0%i0V%K+p&^rO?J*>0CW7&_xlaiCZaU#`!@cj?p{VrDI4gh#?>UT3P-PLn6 zd*s=6w_LjF#=Ut(j(z5=bG9HV&9vskeNH1y`|1H}W+gK9B`%o1%0|E<4y=ICWcH@`-ET8gZ6Cws zKEsCoWvA;x@X1uPm;Nyx>E3%hdyVJ#hdsxQU!vLWo@sx^8{vMQ8*s~m-1nb74t0CE z8r@#|?9uM&@Hf}dQyAzuy1|#LE$;8{U<(H~`2XeiN7wIblcU%@(&4N$t@zlv48F(M z6=3{`{qWU4oF9gND1{*_=S-h*Vbh#j{WL{J6wKO<(2fP&R);d0-W1GIc?_(iw670e zi`H#}+X`N}AsJD}mpplM{C`O7?;#V{eq(%+D<*>6YspEsoID`GUnAt=s;}Pt_T5GL z(Nw=JNGJUYncvdk-PYXJY5jC8&Q`w?$D5!3hvVcXgy?a!S4A!Z z(xrR&e-*GS9Fe&QRHXNRWcYkAa8+;<0z_JsZPSR5P9MJb5z)T`3Raf0IkZO7>08bt#|iIcvP}ubTINg zZf3jgwSkp$*1X;vmyCA5X82J#2k9D{LfT2Z@L1Zt;H=q=Ty)`<^~Wg)zK_PeQAg@A zOEycHxPmNv9eD@lE$v(y<#Y@r%|WJo&vm(82&B*%K#|5A%^DML45rP%wZZh;z84P0@K4&Z1Jiqzz%Q3v1Ed=_^-k=r^>xfQ~McCkEnU?ekMUMXyZ@~NU?0? z+|ypKdG|!fDkxp$0gdsV0_TJH~ch0rfJ>v7)>p5QfiAvwEjqyI-$j@XdjnjX%luk6Zf6wH6j~q^Ha96%O zdKryE^rKk~uZ=gAYkQ>})i}!&cQVe3og*@a6Vie^Y(l+!Mss(^^+v^NGo!N>h^tD z?T2pq&iT+`(#cBSydUC2v{w-bAnLjgAQ#fmM`UE8`=nD)x3kdXHv|{r?u9O*(WFkR z$_rOHCv}&vFJrl#Kr=gJxpQ8+bo^QGi`_cDY0SWJNXMVd7i9Cd;E2&}QiJcvCdLva znPl<}H~|PNDSUkgnq$+-$+*0O)uD#GunqVt6lO2bq*djx-l7)_3j*K!l}z@x#Gb2f ziMxo)@5r>3*1zn+zel;|2<1FU8+2Owlg9*~8~c_X?L&fdk00+2!~?6xZtxMr#aYKn zktJ^*>(A*g;Iv$em)5ZzqEu0(@Al;yAIzFH<1xko}1bA8FwF>WYc=ZCMBfynkQ3V1G$Lxs=Tf9ooIwt~c^ zE6p})Z?K6$=)ZU=hlBq7PxQdw+hQIK%IRxDd!E3Bq5@8DkDoIoCxp|`z{-55we{8c zoN?MuU)2jU5VG7lbniR;7qiH6C^O;zrgpsDtv^`Z66wWA<8bK+zUb(V2|M%QQqX6Y z9pu6cM8%=s#ixdJ!wGbwxP;FbjxyoG#?R;;&;5rh7tR^2kXNbR8-*jY*{#pMs;jfH zJx^TvWlmn6vkl+<*V=&K1&77XK!pP@{fzE*gjYNLgD4;-XGfDI);pqlZ}M;-Heo`D z!J~!%`fq=65>2{v?pNE0Ohu>u=+e1aN0k#($vsgOdt%=?5|7xwSVvVM@6#OmHT3;> zDTl*2?|T{N{o#%2zrYUG265_4h@=teCJfpbT}wcE-c%?-hy{N~5`gLd?K^YjXmtMU zIh>vU_2;nuVW;lxQMO#lS9hCQzcOS({aDU0>DZ$jX`c^$j@012oNZv2Rrh<5t&MW? z^ea8_^BIX9;d=C)ch3J21ogokhZ5vI~h+qLVf;kJd=>pFIKf8=J@ZH!%$Bsll_o+5YkPHh$lpkiXWm z`G{x6K4cJU^Pj)ZpSSU4AF(+>o+%#g<7(sDTvr>94d9|S{`#_w2l6)kzKuT4aX`7` zgWNR6L+3do){puRr(Zl^^Vg#o`Pwl@Im2GCeiy=v89EDvAcIkqwEDHTTyuu)H+Ih8 zXTJJ@ z8xce2!~MJSyY2FGHNConay8xEgLUIf$!?R%6F$o8biduueeROd?r4x>){Yr_1Ys4R zZWeo?{`VVvl&u6{#GJujXwciaLjAt%+ZB#u-%jd$>7U1PcGvY?6fAFaN4&;;$^6pK zwkuVR+zo~mW4?CoJ$kazH^DZrc>Li-({ zea4fGvd;T}sA^CZB9)OM8n~gC^jy<)lxY4v8I1ZPUdrK|Mn_Lh7rXzs@cx%@h9b_m z+|T{^pL@R>mFxAPpIrVG4m?v-O>24NR{x(u(I3ILp)a|O*tz1CPZQCpGw$`D^3#p~ zX+kt|#|<6!kCc>HPe^L)(2!})!lckoSoW#mN%1qjVS&oJ<$j<~AAdjXtLf8{{>h@- zM11KVJO0bqaVcLSir#T4pND;kaQ+aQ847o?EO67l2w^GU5TpqD>m&BBkGt35c=+G& z%WkuE=rwm8&Y#bPs~)QHuGElJb_dEk68^iWn42H&-_sI#Ahn%$qE%Ah3|na>>}mY!tPM4+A(w+RRI}WNh1`)~fh=R(7y+^u(M5k_t{0NVtZy?e zVpd_F29Kxmqu0m(B#-%O4n9FY@8#qNf~dw6Nr7a(#ixHLBq(F ze`eBFG6@+Qg=nXC#H{~eHv1jq%)j;bhV$`)?>ua3%(3QrC!3ni>vDseO-+U3`=`6b z_cxU0F*dJ0Zbz4YSx%Wqh0+gRaW_osaz;!;&Iq?^{BS_t?Q-O2U^|$_YIr<(Lu_xR zxBka7r`j1r1>i0+wC@|=Ch)59;?O_1+0^uZ;kBT|q%XQLo?S$2YMVGL<5`M7O2Vu1 zLP{Iei3Y)7h>tY0Y-$bJEjpJEQ;X8@KDyKG4XROwLU|4fk@tQLv8iof+0;gNd-ikm z>@qF;Z1qcQW_Ey^w&}Az(HhXxJ}G{gBR1TVP#{HjY~_q9XIs-t>xbe*>sV0aqXWAa z@1u46?`+Ply&fsTVwAoYq{{O2cvE_1zv-F6%4`M&GEK>H(u172IXEyATSDO97*r@Jy)2nuTEc$&FsEE-$0 zq|UuS-<@KZj1m&MV_bd0Vw5+1S3C!0Sj4gUiR%+>;o?6ZgRXh~Cpye$&M|V?R4)75 zm21bwvEJ?)GyK)Mg+JA4{u?zIr0yf_W7@0r^*^}ujqvI&3m4S}Ba_Sv6|pu<9dqQs zJDDH(hN?T(($EJsURn2{i$wR?d4ss5C`&JwaL(1kg#2^gPy@InphsBVs*EbFx z``dliljqtae(y`E=F~c`eIPcvie+4`Ft5GuJdYMt9TvDfD(601;~RWlvUA=go_6@7cKnw8sMQ~TaSatzQ7A+FH7BA|aGA(eyZ@u-(Hkr$@LhNgdU(9lBAh(NkCWFHcWH7XxwpP zfpe3YE*Bt%Fs(Oo1r0^?eaMNpi<*OcQDWw=H0yWq@`@UYXhc!HHG1|F^sd81%v*UU zyniXd%!5o9N5V<(P1`ZaV0+_8IODy4J0=?}ZypKfyc08hBjJL#y%bXqF26St zn!L}KW0t|vz){fbeQ!7B7;Ks`3a)#<*o!HKM5T^`o8J0;m}-bVZ4~_KZQO?$hgj#1 zf;-;#jF@9c)WT6HFkG-7GrZrhViY{{-nSn!zpuYC3Oc>>D=}Kew2XpmOkaul$)s(g zAP=jp#FR4Ay-_e5D?5y-Wev|pfd(@l#&j~%^HDGldwv)*%S?0t6ktUr%qG(d0$?H5 zWWxMLl#2pjG1h6q6eF~f09cAGt-@3zQhEl!a%^uErW=vcI{;QBs;uU=>F( z-AGeF0Bpl99mUKeCu{EbLzo3-9fp8tmIfE&KnErwAE4KCwrU^0)2!s~w z+8N9cWFHa;x3T$WF>?@SWFXwZOlL7$5CjCmJwB|)$S zUv?EUgfcyYU>ja`6*GrIpCH(dcU;A6p$+|mpbR%&!{{*6;2_w6-?)bPg{8b71iR4I zh$+IPBZ6QLUVa@@g~6yG*oU9Fj%mX5fkChzZ@rEg!s12;!9je-4a^*-jSPZAc+pMF z7N(63g2VW}n;0D)H7N+HaO+LXFC3->!BKquEld$^nh^xY@YY+HDjbr7;Aec#ub3uW zo)H8!_%a)22xsO7!3n(7hMB_~<^@4Le$0m1!W-rX!704WhS3r7g+Xu{U)_TFMdYc$-$&)>%+6Rdqk!vnnKJ|>%x(tk8O!YdzO$_eE|M#E$L z=>tqXAw@PC9QgW&m~Mi7)M$8y*FVH86F5Pmp%ZU?h)I<4(W4=UfJc}@X;O@aS%mHp zrc%m7M?*eQ{s=QFwc(>-K5_LCMo(lWjfO(v*l(EML_0cNOssi~DJC`~jE1Ge>BpFA zqC9ytEGK?>f@vnE%pVP_h%*k%GEuu=G^`;mJ;fXorQ1e>o;cKwNur@-G^``my})GA zDIx`IAok|q%4i5zz$W5s9tS??*}6tR0DE}87#p@6eQ^FmxPS=*_A^TdmVxN33(Hw1nmHfnLr zWGz1gE)vaJ+%P##6atrsr&`=RnURFRWnxt!ZkycDCj_n#Hw$rkO4NW5xJv9=g!@gg z4h(_oMEfFKF-0m1ft!SOF|L|o4+w!@iOY*|%@k8m2(%DCFTo8{Ov(_rP1G#K%~Mh) zhrk`;_EOw7#Xm6w9uS9@;j&ok^bmMN>|c&6W35>s@R-Qg;p$jCvjDWJ7P@>LIB98I$WZX>p~!hJh}pxsjRC)AdkGb z0#~XU)`Y-pGJ7SiR+$VTpdq)c#C58MZ6Pq1ys;8Ds!XLJFrP&GjYVZQhQI=HWfAUB z`5z1cE%|d1E|~_EA+U(F7vZvLa&rhQAs4N}mD8*>A+U_xvG)1L?d9a*yq*G)^Q z4}q2BwNZR>xFnGY3Wc5I-SxOE(LXE{c9T^baAl%3JQVhl7dPPQM3@)~Msoc| zT$gB#4uu2ck&U=9F>Z1wRFGFU;+8~fY$#Nci#FkoL~UXypnUR8xMX_Nj8Hg2-q?i8 zrrVQ3p_TX5x!sFk5`fh^sEt7mA7 zLcv0A*^29C*vmqpk-W4GH_nir2!$rnRDxS(SnEQenY>nlJ7(A$L%~XRY{w-@`a7X; zjoe&@%aY{JLg5D4S%xc<%IPq;MJ_AH)k#spFtCxTx^4DFsBiVm+7y$Kb7cNno zLc$=2+PWK;sr|#kAdfn?8&|5Okzp{Ky1g4$tK%kwfre_{gX`4g31Kjo>fDPP)uxOv zm`^qC!!2r<83qfej(xa8&6yttS}JcpE=kp{4ueJ1>I1keRlhY1mQZa6aAm5tEDV-W zc?WTIs((co=%|wiab2qRP#CPF?i|F8sf;-cR#EdSa7(JTHVoEKhbnMKs{CXa=&7~} zT$0AIguyy$;UQd>roR{l8>n4}aAjIbQy6TbY=>}lTHKW|Fi<&_xGqg^3xloHno8W5 z*3cRTCDg%6+>#d876zr%`AXc8#@r2qa;l{gm!#_*VX%{0dKj0b$2|*!-Bi_KT$yg_ z2!p*;i3wMyGd|&9q$;X#UAh#>)&rFG2yRTb_78^&YUdH$l5QOm4wcl_qqrkIWpp^0 zs9n{#B!d$k4o9f=YFw6)q6~*>YSA%VnZZmBhvQV!Fcnx}k|9kFhm%zMaomw%Rfj_ZwfbjVk_lhaIG zGE=SzhYOU}jH@#tKO8Jni5b^rmd^`^Myke)8#Cnv;m|}~H{+H}`+{(2rkDq9(MOkZc^-TYR;b5cY*WtRE%*k+Q zrS8??#+ePL!l8{Stj8@gO_#&rF16_-?wBccgoB-`JB3TKw9mug0ae_9%d)Jz2zW&8 zZ@`sV;1dClsoc}JI?F1F00*`1G_K2v>lFd*RMlzRm}Tt~0UgwX)3_x|+dl$2sp2!Z zBP(iP1OQ!q2A62;gCZb@ww=Lc8q@m`kVmgRiz_wdBO_ooz3(ip*4RfyfQCMM7T0N{ zK@l*Qwx7j~n)1;RFrS`#4!3CHLLy)Rz2+S5(AdKwKug!3!zKA~5fQM6esT_%fDLr@C0sezUJ(JC=W&nsCcpsE>eB`eqaEn9Dg80p)brWn3~(e<=cX(#J02 zvU%Fe5wM%Sa~W68gDVlRmtNY8tLJH3Bfv;EG~>E?a3=x|&~44QabEeo2&kZEU%@T& z>`x=0lHPR%cg&MNj{p;W?FufLZ|#hLBlP1dxNN?jjzmN(E3CM3ehM!Vj?+7>xOzU~ zat1S9Z^d=a#`$tdB-GIbS8>aHYtKkHNmpFO9rL4lM?wSLa21ynGz^S{ zGxWmixU3*0C=$-m2XElY0&RFCT%dosfvXG3BO}2=@41QV3aqh_&`4jrg&PZ`X_3%G zm;H)c3gWUNp_$IH;f@0B+(@v}J8ZaQLDc+6xJKW!;j#q{3nJkLo!5dZ7f4q`!Yz7D z3$9)ew=xoJ^v)Jsx4^V25?bkBT5#in@->mrMz^=%mIdWokS0p6Z^a!8?As#2PS>~M zl7-ssk??@N+KMX{>JLW3Z*(! z!t%?J&`DpvgF6<&l}G??-d$Xx)3!!J4mbB6F4MuYNXX;fy@xAxa^3`(&26;fY8|J? z1kiAg-^X=2Q{M?Nm%H-;Zr14sPJjaLy$85W$B|8dh1?|%ae9US$O%x$-TM&tTOkja z0E@YG4{^l`dEf+C%58dxt5(Q^CctuT+e2KlLOyx|tl)M$#0@LtiV0A}o&N|ouYiyV zu$sH;5$;$akDLI-+>O8Cek=8f6JR}e)e~H?lF6I^8@aVlan(xw>Itx!d+#Z(St&P6 zfGym8?YLnjQ#t{*ahE*9%`2l0On~j&MIE?prKxrTlyNN`I9(LgJOOraH)a!lMbK9X zySVK+grX=)ri49QZ7!iI;*3LQ@nMpoIP0)47D92qKhlkZa8&%ta8XghO0M z9$_nrD^S8=?#_IIUS(aagevZ#xrE;;rc?<>xd-MEidFiGHN26=GH7G z{8pC-PK2}EJxd71YEJk>IL~cZLa0{DBPYTy+&xPP&1&hSiExqIxs))hwl0_mm$IK89c9`|H1 zL9f;JkB0l)&FcuiwGHn_!$a=8^@L(=d0;gBhET%@)mm*xG(6#+-au&9nj)g%Dfh+( z!mu`FQZzi{Uf4*O*P5n8!*eb&JZx+2)1u)8cl#!SHb8PTWb=+~Cj1Q2%xK8vZ8H!G zL)^S*n8oWb5Gq5|ifEX_+qH$z7|M&HA)j|@3t=!st&N6xyysg8vw_(X4F$XvTM3&% zzAYLS@)mC+=q)J+qM?xY^ESe7OUj{WSj<~nLMXPR)JDTno~49PZHcl(!*brv?Sy8F zv?&@^@J?+f3|su0qoIhGQ%ab(Xj`ITHLtjoux(*(N5fj))l!1qYQGx|#k?n_gx^+c zdo--)<(3nQtqeB?HuCnB6RNFNVGI~}ZRLb+Yn&_ww({2QB8*$5qhp|icVjnU+3G(b z21aE5oJl8|j@?!>@3US}nt+-`pw0~dJ4!-RT!TxSeec#jVg zy6p^i5;XEwmmTZEGTQW%d)3p`CZ7i7=MMotg|Cyu8bVrHpfNGIa8EmkCE1b7?XF|JY?hVvK8^ z3_1L}mkF6sYMTss{DNjeX|&&-472(5&4k)$y*n8+{Kr;8XJjN(U@m|6Rl;cG^qvCq z`R1#H#mMP11s3p^Un3kw>3}Jq-CKn0fGK$jY~XMCl~5i?$(RD0_?Lbq)CZ(lQ^3H#Xd`q7m<3Z{ zEB|f_VLZ^Vb_$g6XSEWR1J;r$P|Cm4N;nRfj8mYTUwoU89E3wtU?;z-jgTFTIyD7$ z^Rw>~%7f531@`iv-6PZowW3%s@^c;#x`WdGv2cKIc|aHs#wlZ=g0K6HupE@f#6l&% z`ZvOH&>9;HCjNrQgrveWEf$XOw>>6g6%C28P|d&am{3+|lVagG|IuSYUE!Y=3ugYd zCxosdEYO>0Lul8O#G zCV*bhww09C#+48P^@B*JOI#a*Ody?k^coD~%9CKdHj;fZiwaCSGT zs@G0TgkJ>P_mG-;Q%oXU6twIi4fX!h65*1-xR*57bEYT4Wx?6Kq^(|_oCsG0^Y)SS zNquS}TooMONBW(#&P;^s0=~i+69{qk;YRgO^MJUXgWk%PH}9B&?%^>Bps*V zULt^S_F+PW*yd;N4M5*q4B^ToL4>9AUO;S_1RXnj5%)(UT(BI!nJ=X59* z9&aH18kwFmV7+kJ8B)>MFn9)R6s|l=sv1orXTWA*CK#g$g z71Ge;-!TJD2(Mlt%}v_Q8Bi~LeucC(`SX(ClyIAsq%Yg~NpM>Dvz7F_EEOfeS>dl& zNyTN8UlN=bZoWpUE}I4=!7svd*GSD}>5wG2C|rD+M;O%mJ@wzrYCW~Mm_?g{O8NcxK0mIU{O3-6MC zS4=HQ@K9*KODe9|?~Q{jz!q~VI`MG`y{>g=TX zik_DY&xL#Jr0q%rKN(&Kuh~i3W)&qvw&DR(ZOoqiG>tj;UB27<*r6SW4Qq|(WG8vYO_C6&wEmlJ^tPrhlCk-tPWyw$^ zI{l0^x9H8uuv&DpgS53kV=}B28K0AMtF$#4ibZXmq+hG{UNWo~mA@brt=1RGuu*gj zC{?SehZ;7Ewq{eBR!(0vY!OxEP=;3fAT?|gt;nU!t#KpOuw7)&rEIO7P&Jf^%JL}s zHiWBThv;%1<#(GiK@Gb^&+;h6?eZ8k>=7NGMX7FEC#hkd=<+N|b6Xy(hW(<|vnj*v zs01|}6gAGK%(t0TH5?M{oY)Yh9jc08cNnyzCaDtqU-sTvdy|i z4aY@!b18M3|28$4MK|YCx;FnZHPni7=TXKs&VDu2i7w2eEN%KqHJlVZokuy^?6qoW z5M7;5N$$j1)Nn?$pn#IyVH(wNPV{R5rMx4(qJ|5ijSDFC9n)z`mT0hD%eEzizwY){~@W+Dq6mnGTyZZr9zwN#bU~GmlKu>cSVnu zP>#EC(Wzh;U0O;>?rCFF;elwuGD>z&nwSc|iRLV)RQIH*sqjQpy`0kAgQ8S;D!RRb zGTe(>n+nfF3szF*dz`JQ@LW{8lCs^C8&lzhXm1fkJM@QAA=~F!5hZh&YEogAk9ifP za`>N2g*iS2t0|4cdNCF9eYUTr3=V5kD$Mg~Urm`EQMObl@L95kvN`-)Q(>Xc?KKqr zH0oI@6#AIfQhraNBNZ0=oLNgLp6Z{c!cw1`Ybn)J&Wlu7?qe#ZG*6{{(_n?q^J2>I z6#UYl$YnOUNBTIu~pQ81YUpr@18m#xZxSmq9 zM=8=^qmOn2rEZr`Oap_@&W)6zoijNNw)tG!NSWKUv1zc~X9e=lwo4P!pv>pzO%(l1 zo|FbVeCjt-e$N`R(qNZQy@66Z(=JGZJwBZVO7%>;G7a|m9N$7|p2@eQ!G52MTPedc ze`6XP^jWx#GCzwumKON5cY}i35p4)q-!+D?D9hB;MRNr*?#b^CaO7ol< zm<|_xs&-O_=hi{#aLH%MF3S8IMyA7MpMAS1+j9s?hbunIc2jg`d00AJ^*Oqm^6QL? zNQdh_x;>Pl(?2>LZu*?wL#aApN;>@N^JEXD=}bvThZdhbdnrSwG$|c!`z+Z2SxVc^_r#G-=Y|o{!E*(Jz>J>2TlYvXSz85w##49{SudQi>P)73uJsPt|@(^}>I3 zIy~|Dbw8zfAvL7KQ=jq!l;MTkm=4c;79XU{FE|zH@Z1Nvw{0)1wdwG}r@4Zn>C-3E zA)9Hhp#11!OFHB-D-Tf$I=d+yW-*3JN=0YiPKP;6Z6&3l``t;0eCA3eWuU9>ro%jD z>0!!Ddv&Bk0aJgNveBoXr^7<#=3$EF26Ho@klA3O{J7ct3|P#VO_YM`CCq@O%smsO z;(qIs0n3>=Rg{Js+$#fCFh{B=16SN91B#gDD$2|)d@}=9Gmon%8~1eI3|Py|J3`UC z_<wWX`$s7a&nqMYwlFKIDFg3x zSO#okE>u%y-q3^$*v{0~P&VHE)frIE{8~dv`1jXlz)r?cOUd|E+cID`bGDXJ^81x$ zz+NWz1f}MGwm$=m%*_*&j(^&m0SB0Kb(E1`Ri6PB%$|D6!Y^#ffJ(+%PdWHInlr$} zEIdg`1UuR?;0V)nl9CDHpJqTcbLbSM6rAqJfa6TZDM~G<;$?!F+226v1o1wZP|GYk zO&J9{`eZ^KV>?Y*1Xl-S!bxV%S;`@}IwBJqm`!IXiSXN?OgO`IoTX$!uh2|5$Lu*r zDTRd*nQ(zwd!AAYvtu*C!YsT%>4e`-%Y;V8a)B}ni<2^;nc4me2;&RwK*qT(%?(8_FSq|74m zwoJIg9BHH+qN`<@U}rX7q9i_r2Q%RT(|C!J`D9mS!XxIuf0pjdYx{a z3A@Dy?^4QM_uFQ|Ua{sLrS9d`F%yj9xpqp|tDhhX4v0_LDPynCBw0`)UUZ+b^g7)m z3o6CC?^BLmg#)s{B);;1lJw3Vkp)M@M;}tM-d6*%pjv$KA*JknIw%W{i#I)@)V+s> zWr0~-`H0f>jt|d*TJgz8l(DyXViwei*ZxLXdVi+Mf|KG6k10p*q0_UVL2P+UN%~}~ zv*3)__=J-63C_%dbK)CMC}p4EtSq=7&T~-eKJockU=f!&C|#d^^Ru8)Ybx3#{Ufc1rT*)dN{@O}zIRC42Mg!7R8Tu6af&-#lHJ z1-HZ{9hCabsuNjY6F=*qbZ_pkWI?OA=s9J4b7*rGw25y&rz~$~w`9RxaY-lTcymWv z7TCpSJ1I%up?9<3fmr{7lJ(7Q&w@u{;|ogJ_p^>Hcr3o~f>QVO;%dMl-UhU;?@)mT z+QkR5X=C5ddTXFV+?GvS`d0PTK&NE-e{QbwC5_ zeDmhhvH`(08ra}#o=+H)6^gGv$q$GI$`S z!R!A$on_9@q~iVj>3i?qx?xA26ai%(om;5h-xf@cfa4yqTPeu|_o)$Z!sEhLDsV#m zM-gz!CQ0583@Cf|m*qu8m+k}FZ5m4)Kb0oX{7a@e>?aCjWZpfr<(6C&ZEM?(e`GC6coBs}(L-c5y1cFc%`UXOx3lyS0S zRwO+0sNF-ECl}0*gnp05`zYIF_wYy<^w_eW>YZG_A`-weXFnwgtX~xgYdzccQ-Og& zQIW9T^R|f!2@Fb!giW4nvnWHLduAj=dLGNBtby+3kr3kOw*S|L4~KGgfdNYR763QXKo2)ofcme1vQ?Q63RYJUlRp&p8X{hH9fc~ z3hF)2mQtGO>1|PP!85*$(oRpm8wHm<_2raqdVFsbT=BeKP8p^LOgT=Orn@uI z(BxThoU%?2eKi_dJO__c_UWOLXlV0{w@}pk!Ln#*_w2S%n)ln4(Qw@}>I9{I-!d*5 zZhBrmLFwLapA-$ZJ=;%GhW9P+M?;6_)>D+}{eX|6;jZVQQ9oNm(Xh$uUKM4~>dT`c!Yi$sGHKnbq9MxbbTwtw3TvYw z#w)glvTNO2qan`AQA1HP>pP+$-mAHm(#(wSjfSmW<~m9{GiWdxwtLmoQ@WW#{}|Zm zReGK>%&eah0|{Qa7bw%r`k671$eI1`c`MY^1ca;`3wR zh*x|QrJEIB7z4+=_B2t3S^AO~DD>LUOqphdR>VND*STiOI!j+01EpTAEtGv$d}|Dp zdu?u|sM*3hF<|k^ZlyG{EnP8i(krHo(#{t4$G~Z?nl?%|JAjUbvtIkJQij=~Oe|D* z-MLDcW~WPIp~|bgowCjjlgC1hS7SS6pY0eI3w2&cuTj*T;0du%@6~&a(#$EC8VeV^ zs;^VpIq5TE;gZ+J8eN`c>$T+$Wu5Du6$@QnrFSU%TuV+YIJ`RVP?~wdvRHWF z_24e0o#$Q~3y-|wyC~hff|gi#;+57-8Rn(miG``+UnZBcyp>TSrq1LT4Bu-Fy9dTC*T%rV(~~x2>nO3oLVuu-ALT z23ofuV1W_#duMN;4GSC#jgaYma|3N!P`|_o+1~n%v~@we&Iq~Qdp6Sc1wmgMA>TV? z6HP6QUu}c}?_vY3Ss0LLghSp15wv!pBgqIyylW$9-9k%>5srD^i=Yh)3(|~G=xvCk zO$!4ujZo~J5lLGYI&zFq>U}Sgwl9n~8=>6$a1>1~3Mw&z#k(zv)+`DuGr~#lwb8V8 zk)_fIr@b4ZY2Bi*S|gnGei}_17S-E~P~lx1Lz@;^>_({aPL8Fmi}amFsPQ($(e_1Q zeMYGBJ{3n(i!J>|sP~4=v}SQIn*bNQZ*Qixiyi(6aLIe!R$8|>U`hg9@vh%W8y2U3 zmH-Xj8+Op9#qD1wK$G|OowRjv!A}X$;$6Ozwl8+9N`N+R`%ao#5^6|*cJEjtty!Xu zOn~d&RwJ!lB8*9Zo8C8!v~GzdHUVyXZ%UvIOTrQopu>A0fi^7(%}Ic}-rJLC>ym=< z1nBaPNT%&e!YUG=$2&8brao)0N&ts{9(Z3*rnR3H*b?B8cTNhe`^>#L z0iJlDOQ8*)Sy~d{sdsk@ZTc*E2pfE^@1k|OP-!A;^4XnE8+2+}B1HJKrPC&zP?HEz zJ_#ALRTnlP5n_C;@sinbF5+UB_Lg`eLg$0Xv0?l*@=+p)0$12zKXXdLat9{4sHJ`xGfR# zecJPA>T4mB1O+~61+?aCwJZq^`8+G2wO^|zC&3Y)1BYnc*X?tX;FwSMVcPJuWmysw z`m`UVO<#wuN`hh^y_vRt9Tt-Wr9KITwEgRVlq4wkxm`$8%hI!xz~Xbgh}JBNFHVA! zJ`p9fc3FE>5}fvVR6^^P1>2I~tWQ-bZCIvnNrDQWr=_%MSx{#ZRQVXnY3nk}KoZpW z+$pE+%PgW~sPlPtoTk3fOOm19XRC$Qd{ZDzh6_Gf7FzpFy(}3n`K&!b>%MVllHrQa z?h~}(8{x!cXz+P($sSOtYm2S zxp9itEVs-}hU-30PSM)sj(N#&(ty}I`nhdvnPFZQgaz}JBboj(q(5B^K$;oin zC$W;YE)U92hAyATD%!rhy)YSid~&L2>RU%iGB|v;R@0hqg_X(hz^Aa9)_xmSlMIi1 z+Nx>Yw*hs@@WdyfhBkcb-k1zeeU8-7rf=(;lA+JXRzq9A)wd?YfKO#DZU0vIG#Q3` zn(JsPyq!q_y>In7S`(hmrocMiTjywPc+jgUu))_*PwT?N6e+ODx1*jmgbOt(5aGM? zJZ%cMj8B0m-%ICdYq)!03dH#CxIo*(L#L)dobS;KG_@jqS_*9OeQ<#eTp^sB0^58a zT%*le#Vi_W5SF(BVG?*i*pd zThU4ze+uYLfh^yxZM6BP^q~~U@jZE!w*4ezQz6ecs-5orDNKR5@%tR!QA?llNo(_pitbAS$vaI~etHp#9*IwT_aZW`>6Gz`+=5y9PQ zV3hO^(#8n)XK9cqDHx*75yJj7NS1UB(Y6TOx*=84s2BA{glSB$OLBIdND?WWVS)_F z@eQKD$e?8=*dtkQ5QRhrN0?xrB+DQQk1R+vfl0COltky~_j#C41sTfl*=4OmJ9oC{7d-WeLfIqmrH5 zMd48a3o^khS-(SMj0#wq2}P3B9U^O#`|?aEmGtZo*`w0G&4hAE)J_oA%f_E0Tr`ks-!0B?}rPxw}QCnD&KP&?G6{FS5o2L}WpW#E>bn$FwJBL7U`$rihBQ zShJvAaydt&iFGt(!F5S(u1Fgjd?yQTN)F_Sbg@A_S#VntpD!}R3J0^GLt@VtnPS`N zY`81QJ0P;ghBDdEB{_3IWRJCs$%Y=u-U1O7SMQe%4#|}QktVLdKN}uM;tq|pO_6#Bu@^C3~`Rh+3-}d^^nLE7cey&`XnWXMAkUr^lTWAI1Y*Iaq%;< zVMr2#zXijnpP3DM>F&cKjWK9eHmsALIxNx}+e5NpgY@_jku6OZAU}~W5AMZ zh>+epA~G2ZKFfwEX~a>H)mZRtHpEDaj*0BX^flQKC*5ckQ3*j2*$^)^nMIm}g4k@> zD(y9kv4yIgl-_t`b=j)#W*mD_vhLvL^;r9H%KkmS%+xo}2$`HCn!Ic#+e6y?Hs>B%Nh zU`l#vE?kseYZ8T|1Xt$5WocKlC_Kf{lnXX#WsAs|BJ9Y8Mrlf`$ehyNoeRy!De zN@!m$v`TB*M7=2mgSl{3`k+lDNe!d&;F>h|swglun8|}1(u%91kW_az4{k|2uZqG` zgJpSOm-e@djH&6GJh&s>eobUf)lbZWPU+QaB3o+vq&(=B9=O;u0JgL~5R*F}=F zpjmlvUkW!xfoZ{u^5CKL!c9>~TG*02cq~17OB9|K`coeCN_W^rrnLB|Jm`~l*+urW zpoBaak|uSED3iV_5A=Q~J4G5(dQBdz^K*2Hw5Cv79&GU2*Co=K(wp;OlV3xZ$Y@Hx zlLwK0N4iC3Q&49fMEiAii)^O)-aLr)%jgmHn%w*HV6$Iok4TakFpvjZ{F-`1ftjI0 zd9ckd<(?=cGgO=pJNz!*6NP7nj>!k3-?MunV`h+FJ|y}%93pe3P?HbIe$n?uw#&`M#((Ghk9a?DBhZUnI#23(SWMza0-mfm!KO^I?x))dNvTR{V^7*ymUJP!ygO zJUbsueytBh#;o|c`HRX!Z?JM~zk%P#mPACCETJQf+UgTKv(Lcf8>B2#vJcs>;S9e5(L zW(Tdxhf=>APek_Yf;IV2?ibN3qH=;G^1l(! znxWn=e;uRARnIWP1;5_)j5fD^z8Nn0nKv-H+|VUvxZ>BnfidJ-J~Kmu-=>X>DYyMA zGc@@XZDg#u?#s>4;`eAHW6upr?S5xAF`B&gRc5&E*Sd+(=IPVS zaMRBk$>{RJip_A_?@Sb9$P2A7LxtuHl z7_GS=s}MHG@{$;xIiR!q7Wiv*~yH_9Nbw5QL?RRjMXfpiXcW7w~Mix z!`LE-lO0TFsKR<#5yZ>ZXE2(=_6bF>Ro0xrXbXb^i(tDfdN-phZ2z_hcFMNzXAFgU zV-Y0CHfJ)X!my+wNRl1TVyuP1c}0*SgKWlL7+h2YX|mjGhAJv3E`oGfdp4sfaxX7} z-LlvmMq3nGSp<7!Cvq5FQE*KW?3dlhWei0DZAFkN+nC3giu4^tkS#lq$5@NhT}6;9 zJCM)Vi_!;*AYT@DfT4=R#Klk`YdOGZii5`#!y(y|1B|vfKvE1xWO)UQt~g#+498@r z3K&DNLtYGpvMU9QsaWk_48^i-2N`Q|(0KfTSlRi5OmDGpaxom2Z92qAN`&tf!wK2V zLyWd0XjUYAuo$Xjg~g1uB)+m3YGf&; zjJ-tPR19^p3#ANIs&6fZdfDbOMpGKrT?`jwTgn-2Y1m*fT#`L5XLP0YbO~IMT|3Sg zO5tcKQ@!Dr=u#0(WJFrx{yW z(Bcy4mYL2ly=D5ZOW>aDdIcjXFGwwc`?8cuCa^p#w*(%_qN|vYa`(~_cr5FyV#3RX zRVC0XYpZ6AOQU%Hp(l`GvQYEDWzbLr(Ix-*5K)-5Gmhzkuh6?KPrW2 zdHqGkW^JES3bFF8i%hRIAOwGBhJ5EGMpDtfpcJ;qZ(d>oD+<0Ug>CYqmzj`?u;rz& zLk?G%@QU^orC^lryTTYN(pQ#3qWtO=#$2IaT?)za{ws{FBFIn*sq!=%(_2vxQwqD} zNezsoGCr{sGUT-lOkibDS}E+2$2Bt{mG#x7uuq=d!h~0*H_ zs$gar9GCCA!APpzXO+PTdD#snusVKr8Jv$ezV zb^G!%sFXjx#h9yu!^@yrzWp|1t1kGt3~J?fZ!^8sVG(6;PJXh3k<_SD%HX{GP6rcM z)1Foa7v+_An2;K^wG1xHw{|k&HTv2zu*n~EGRB&qhB9cB-|c41HK9Fa&@9jEVQe*F zgJsYv@9ANBYt(c(T$OKjFp}DOX*pbzn;cAFZLq8yZpe>2n2=hFq8x6?A2^us+H_4h z*yXAB8Dnky_;R=-H{WN>wE+{#p;KOWpRv`ZPb`OS`JMYrZ*Bd&a=0gtdc;WT;un>} zeR<0xCa|u4NjW@}mp@@b>Kv=f;juiimoe1^MVCXLysDS6)~RF4VL;x{%h>CLvE?u% zzun7Fwt~cR&?^o-Wi+<-)N)v-=zq#+Z9%4T*r3?@jM3Q&GRt9;BJ&wzu(@ZKLxiI0 z8Dp}go68|eQP{^=ZTgaOh*4bVW9&9Z8U7TvVz7^)8r&<&AzqQv&uALltIA=k!q(4d z8v<&}VY}iV zy0;wC6!Ak0)#!Ly4(W=lAx6^}-&YR16{m+7ZDW0ZIqX$*4l%mMprLZuuUHRaLt~KG z3Ym)YAT~7?ylRDPMTTB%ZPd%HkgGVS7uy>x3M=F*?0PZP6r{95fdbZwHBA-JSl1kU*9vD9J+Wd# zbLdkmR4DeviA~M=0V`A~qBo1J&GB>v)F=ivi|x(9k_xC(^v8>-7U6FzpkA?Wt60+_ zoLK=E6lb@IwJpL06>v$By(4@GuQ*3Ri z|G5HM6}ye%-WGjS1zc4mC5R=h0f`lGO>rba9M~F^Tmd%}wghoVYd}>6+)|uQ7KgV6 z)K!38F_WGyMShCd)@o_4fNsUZ6mf5>#a;pT6#c1UNn2=N z1>9Fy)5L*o!hs5SsOU`-hqSrVmGD@xHeDRvRxhoDr;7Y^v8hccuY^8@HC=3N(<>`s zKw-%c+uMR>R>F`Xd5@T~hs~`7y?^3fvBsXhuoBk!pV%+f+Ur+U!Uq4L{bHRxD6$eZ z`RAC#276FcB}Dk^GsPymC7}|c{BLH8t#;f@$r{KLRNcTT;NUXV|pHT(7{qbl0wRha-RKZ^V zmcwG*9sS%Y*zf=Fu-I_NF|P_T{kI&*l|BO>&Lucr$YN+r(b4qOLY@b&RRsNuRX+ zFF7l=cgC-(hC2U?XT?;P`|4___wPI_)^w$>sfG*wo2+7OS9(-6T=K87igjH9G1YLz ze_e&x&}B)kh6ew%DzT|6tf(5A{O?zZtzGJhYH0CKtQFh4)OV_(&A+EsOm(ZDRYSY~ zx^rSpcL7xc*ZtehiM8GBk{Y<_f2Lln>rVHtf!qFl^9IBNz`wddtnCR(sewoS zrbe-@Cn&!Lp7?KV6B~LQPix?*e|DSL)T8gKfj|fy(je5S{U*l zyeg)8)zVtfEBCdFHN8RdT3Dy7ZWn8N>-}qCgL2z-v97mZb}ejDHr)^#di5c-5TP{Q z6q|bWOKKrXdGDs!+S|UY7Gjk6-$&Sc3s%=coHEWXrk;kD*FwB9x>Kxq8roJ1Ta|-d zV(ru5u3Ffxtn3l%o>~TKVW+aYM{IcNF0O+F<)wRK)6<|ab&#Zta)_-@9r8LzQKsJ) z+n-v-*Fl={?tL-!%<_I6q$}eeiZ#zHAJxHbW&K03_F4R#I@qhc{ZOoXW(lc-{mO%n z#D-@DtLh+AxwBVndZsqkLAEmfso46gAf*m+m4}~+?av(9b&#)I-zTQ}EG2bNpls|D zYx>mIIyj_^>=$eM;w$Rli1JXsSl3rjT?faMxBJD0zWBO2C{&gYh)sR^4*X9$lsSW9 zYhOTT9h53-2gUY2bx$3XD>H}0RDXJ39axkPhs2tG3uS|o%6?$A{b3RtoL1)PSzUj- z%m!zb6?)dtAEdNFg>u(g*3{oV!3I^zrnRiK-+ihLYLrLTvG)F;X*Q@+K3K<61MM?y zP_I0>p4AK#%(lS=Wy^Y2J5WF02A7nFH?X>afJHXAqI7Iv4FdsR*`PsrawBURaR1f@ zP0E3dtaTtb+y*VmoK38Kpnatc+LX3UEHxNputB@>vVqkMs*N_dt~?OIY6l%DHn^#b zk79L$@r5?Ht+Yk4hCzL~4LX$lF|29Oan}ZSl^JoYbuj&z4Z4&qajbnXjBbD)<-W}< zH54Fe0EcpGJgXTBmNmcw<>`18`_t&LEu+MUB%nT)DNC{T+31oYB$<7S-lFRwLeW zrx8x7&gQXN@%_$5IIX&#$LhpudmG`bYI8no5Wn@T5h_&K`K(F&MSmkyskR(otzr+h z32Ibr2UxrK1HUGyQynZ|Db{0Z6V$70hgc1J|Dz_jpwb^jwd{s^mMJ(f1X z6;;|%*1%r-stFoYhGVRWeQR|SG^rjOW3BALh$d)J?KZP^_C!<@w5cwcS!zs%u?gB$ z+Y4FEnDYrua9wqzkkyX)BCQE-sx}s}x-nm5HoeaQCP2fN?3%lC?9ML9fm_#cCvDXE(z-b>%5mD;Ybd88)c1PP016mX*!0N!@;yHAv2{ZiWc; zwhGoHdCAlaQEEdaYn8l|+YB-4wo2A6IbYNaaq6-vmXdBMX@+>Ut%}u1KPYd8t?G5v ztXBF(MKf$yXH>H~>G`T=*r~3nW)0FUHO-KqK2^h-rJvZFAz2+$%i5%$bTmV%dRHym zD_wi18Fs0gYgvh(2h#!>>cVqupx^h>7TBXcR?mj`op`?m_Nkv-V8i_~X0?Dxec~c( z^t(2{1+vtcmsqpkCktC3M}7PfYx6s?s0H%WS1z%=e&?68zybC8%dA9pU)KT$)k&Ax zK-t=_THvsHtBnnjc|^9rQS}iU8!me*rv=RF{zld)`@XORiqt2YShMU}c?*=N9WAU) zmeJJ$WommX+besirv;9yhgw;Q{Cd1CBT>ioMRoVgvohcC^9`_2q6h#Q#KZE8J37^swRn z=LcHBu723V8vXANwZa{BZ%89pz_*`Hh8FxddP+-znIwukJY;$vf;{WAGJZR`uIcEs60Qr4W6lO4_UMF zgSlEgzW4i{}a7~824Gd!s53)whT8$kd$7Zb^W7eFQV29|jjOvU z@tz$vkF8!eMl$Z;bUSPrdu!d8z;U0g$K5yBVb|Dv!x+i<@3ZZY zF}6H%OyKwvW;^T|+Z8n?Wc(-PcGx%88a*a_{P`L?n8tQQk1>w_#Ab)Av72MYn8$zL zXosA!$706V$8Tw|J3l2L}7&wo9GjvqtnjHfW*9yRpUZj^}-Ja@@{(G2p-GI4lDE zEOi0-{Vc@Eap}?Bu>3jtD?B%#Q&|2IoqXLDzZspp{~L51@)1u#C+%5*KGGii%L(*9 zqNkvLFdR>g_vM$|1lUc2HgxiPe4Xu72?XzQ8c9|3)Xj8+bfA8E0pnw*>+~C++zYI=?;J zhx3H+^I&`)I;rnFbjFnj^B19$-}Su`oz&xM=Vf%#&pXgv{Y=K?;c%WqFXR!t>?T-% z@nz`qhx3q*Ux5A*mVI&V%^Y?zfA*kjvHUsuUxuB;ccT9Z%lpyEI&dBDo3FSDzQ^(% z^sr$k@fql|vAl31_u2oh_IIO`y!+7q?23OA*Nz+KoiF$*^lcdT)+B*ot1DiGbC2TI z*J*Uu`l7H6kw7K6N+`@jK{bUK!EF!%pVU6Ld1Jd(d6;hs1k`+??ly zGW6fL^5FPRMaM4-Zlb%^FNt4*PWqF=MKRK!DuG}xIw{XZ{}5kY{csnZ)VCGg)qc{R zml-$b{LVoq=M&d>DbPv&ll=VHhJOvm)3_*I@njyZLMQ#NLg)AYX>?Mr4&7BR8J9M6 z(oQ`(zn!m(xpj92-L>vW{QKxW7~hKSIxmp+{}ugn^atqV_a>0`lm0o3{wFMd@;lx* zs&M@e=h=?V&ohQ~bFQl_bh7?j{q|e*g;+j=zF^o%y&KU zo6*TSBTm}C51s6{uj3{(ix+<%ot($NL&s)2Et7db97 z`p4+M!(Y@jZ#WN`|CEoLU=EhoqLcca?NQ-%4*FlQT#NoG&oj~ghGjKgw2-g6;s?>c z#`6Er$v*A!rM_;0|6#ce{Rf`6qLcaaDP9Ee=a0LDJ0ER8597tJLnrI=F}myejU3k* zbkd)Jco93&pXjei-2{I}*Q1m6y4v$4Iys)p=w!XRybzs?qvj9K$C2ds^yB(LkIwIh z|Dcoga}oUwd?k6vxWuCW1Iy3QN&T+;H;3at4tgF>@{48M`2L9Q8eif8=wuxwqT_NK z$@3*TZsmenbh7SU`FEnbVR;b!m0>62n~F}x<(JrL{Bfb>ZqEIBIr^V?dFG;rWBDNZ z|MC0`I_ckWI0*dn!mA25=Xwi6$J6&nd#0hQu$+RfF8@E#UHM7>zk%+K@oUjv8_q-Wzl**c%UjUD8FmuC z7u}DP(WS#q8eWc0VOfGFHPWxHcAiBiWhFYlpKH+v&J1llAC}o#0xJr2Vg{xcGmfkHlmC5Oflkh0fnM_MnsUBXn0kljG_^ zUxq#dlaP7gYUe^VcOK6|$0m(vUG$3@yR`&V2$cc7276Z7mu$HNv}MgNs6KgJiMlXd$G4CePI`)h99{S}?R?*4^N z_Qx!AvMyc6TY`?&2!z;4uJa>lPbaz>{Y`W%j>NOCy9sny{uuo~!%pVU|In+jdu@}2Knwc!SeDIwz8{i$=V`b+ z(dhg<$IzoO{sDT_a2^u>$8lWzYTW$!@!9C#VBAe~GA~H~kn2FncsIdHEC+uq5d7qF z%(E4p^k)@1zd!GyYtYByp!|jx@A+Fd=lYz9?(cHU{}%e^SpE?s$Kv3BJM85C_p=Gy^oad|1y|J8&?ltV>xZ=?dW7&d!$mLk?hZDJd z<_Fy5UHc4KcZ<=*7#D@k4962+itdi(9q6y|{3mo4%lpvD`$&J1_)Wv{2VaOcqLX%> zKzFs1#ODsjUw$FJ3>~M4;1>Gq;ryh3m`PkezxCJA{X8C>te=n3#}3Dn`7j3^Uj*Ny zyVe)!&#+LaXIFxL?`3ji0;Zy`m+n2oFDtq$$mhNi}e4(cQ{{)ox%4C^wk)5 z8U1Ho{9k_0-5-65i`T&ObLi`^+=RZC=bygIJr7xoi(WD8;gdpI)9&>GTqHteg`KVnZK@jx1*DO-;A#3x$paK&i-}(7d{i? z`OoN>TJR$}HfbbJ8@dF`SI}Miq(Fu3M#n8x(2b5;_elKA8C*Ziz~uaXIF61(A~=Fh zj>FYX|37f^!~+MNwAbb7=wv=@Lm!zBD!hLQ;_^R3Sh!#9z6=gfos{EH8` z{14Fi`8T3(!MOk7q>6XNtMEMdM>pqv$SXKWzTPsMTw zdJ4~9{fnC*5X+Cy-{tvV(8I7i0VkX5xJbQb^xvQ-qrbt6Z$l^Jegb{exTBMK(}4aj zUi>00_ndY*PUPR`f=hfdbT+vu)!LGq-a<0)J)AKf)xB>o9HcB|kZI_W2J zyd+*0%=x7kdQqW55sSq#uh|BRVx#R&=r+ zH=utw98cQ+>%Vf(XDZQgm`2(YjIPG=V|10vG5&k>KVsSEr{~YvNd6<}WSXpYZ%Ie{&NAVcCxU2c8?y$@SKX0K+(O08OT=D2b=!egWMF%U`0C_2JBe^>(0>abJnfANR>2oF9L||A$Wc@#WQ{`*{=kG;|+yavZL9 zo{Aoca{q;|D*M36$KDsaZ|Dlt9C3%R` z3%GR=gRUBOGVbHi$?@c(W7tT&^U(dVT#v5c`8UJy-7my%K__t@@O+;n_2#3$gFXrU zZG3ed*9~;i{x8t^?SG0+j`K%!avZMqyD#M8V_t}V1N~EsOGp1?IG!Bf3UqRQdVr3X zQqDZY?dYT&s(*ezLMHIv7r6=A(QDDK;w!0__`8d_>*2h$yz5~VKCeS3#}lyb`MM+d zd(Z*>U+CCHBlUi}gu8CJj!yP(XMPp#1LzB}JbC@|bxQL1e&*)9?}|Xje@5by(Meu* z1Flt@M^yE&g%MxjTzT!qhp(SO9U*T&KJS+Y>B-y+cY{k9yP#5cVVe*>M&laDt& zpC_c9^cUQ``T-q_BkdfI{#Pt-Lnq_oI^NajWL@1xC-d6X&qj1I?&M~4WZbcX4-Ciq zqVwY`(MkDD^pSOe@z>GG{-Z^A?LVYp?*HV*{eS3qNk3BW8uWH7Uqipj^Uwd~CNN_8 z1a{_5m#gr6ioOHO^CR(l?k>mvkNr32-7omBzvSv&7saa=^K3z1hVQ?J{xvVpAbKK} z7e)&N2`*RR_3MAQ_B=!%X%E)>rjEORjEWh3|F{!<9=_j!K9`s07CNR7%!qyd9F_FX z_e;6!kV^Fb@ZuZMajO*s#Nj;#&;Rii_dFyQ9lLI1e6OM}$MQRyM<4Ipuetk_40K#d zBk}d<*ad=L$Mc@ItMIyO8FyTH=wI^UPok6g@3m$0{Quw^?s>%)bX)=>`K{>Wczw5y zKHk4B=dQ0Z(3kPzE$G{@JO=*{zciBPZ{Kq3A|3sIJg-7ufMp+?4D)&Z`gh!UjwfGS92g`SUy#om>apKqvV~Jb4aj zMW2FY7AI-ou#@wYFpRrC`4C<0^52vDH159sOLQC>?s#!t9Y)`c<;Un5Jpae{+`eSQ zNjS1EVSF<>nJ02wG$Zo_eg1#l1SWJN`hH#>;Sbz+&A>@MGF}+J3H{F)cMAPOUVIHY z85bHC$H=%~eCYqU^KUZxTfF#f=wD#D7Cn^bkI`{T2_`3vKHg0~x(RyF%h9`e@jw0_ z=efzF{omnkf?AAAN)ZTZc=5km!9DNQr9OXtOU@%V&@W(|BuyYV&x=3ylbf@A2fd!> z5i8vUXR%zo3-7IX{_!fVUVZxLdi{TP6WqhNxj0zlILLe;^^RH1`E(piz7L`wz_sps&m-JfFCo8}}(iym7}ox6rXE0tY%abtF&n4zAvP#iQ$;x6{q}95bW@@6~zno#%2XhH*hP_)LQrKOvKIW$kEZvbgKg0rac9_)c`(nguO&0_S+T`hRn_o8UM) z;G!Ty>GF?rxN(_*Cl~&>_~g0?u3+3RanrcWi|;}wagFHw_8-i1bI#XPT-11q9LYa7 zpYtiW==pvJJrd(CqDS!Je>mVKz*B`_F>X$KdG1%h&6Ag~G5mQ#9puhmJ?K5W_+E6f zu3PaSM%MM40zvj6ZeDG+jhi z^U(VkH!hD6ue#z@xX+;9!t!ODyf=B?Y<3ge#&U5B?iD;gS?DIfsVPXu$$(Rrt5=2B zs70LXaI*0I(_*guldtmHkMSRraPwKwK6*aCR?7YS#vOE=x+D3U&`G_AaS`$J?=Iu| zVI?l^k$%AZe=Bzr;L;ULxPkXVygZWQT)o}sIHgDO-$EyG#n=fJo|`P(b>k}Rg!L}R z@tSzT&AA>(Ct(+j^gnZw^OhI91N}J071>A6^UPD+{n`+NSpE?wd78_y-nmuW{@{IY^!_lhn#=P5eIyUY*A4qN$7m0$aTDOF zMexpj92;K#iM5>Hd%-)<@zf&7ejpIwsb}Q4_Sd;Nzt5_BhNbG&p$__ zTQDxDZ}hyHbA?++!hYU5!uGso|;OJe=3Sjf-HAH!do?-)rRZ zm!k96={fXMm}kupul*Rmt;x-~|9*fc{XO_~=W(G=Y3BCxTj)tVzl2WCk9s@_j+`Gc zKD~t-$Juz2%;Lq*ZsqR#9;5H)`9t)*SWfxH=z0^{xa;#EJc-Bh;x$*fby0^tvMyA3 zpNpQ2am(@K&#(8t?QYIE$tyzV_l;f0<#CO>KRt@R%9S7cKMtLg-*OW=e=f{5zRY#b zb6@aH=({jpL-E>!d46+)n^$Mi`SU6Z{Y#9WNeiF<90D2lo5Mf9f&Mjq-Bs@@^aLzR zMMCHECzpHQ;_59xAL$3oa|E4?_s5LTIqzKY|96{nckyVSV&{Hd;yk+ERj&&71a!di zr>yY#b4$$sUWc3Wdg44f*$-U#pP`fE+&qSt2jf@W;oSYz(LRWtjPYC0N9GmAC*I|J z;%lS*_nqAL{jKOJym~L9hhq8P?n1%mJb$N)8{gCD{P8`Az7FGpJVuYpJKfxKr<3TB zygbLz$#Ko`9Nqp8dbpo6uSK87i{CQr3a`3mn}1xr)x8KWEUFW85qs;i%`FZ{O$Ul^Na0%Tt4%isg@e zdHt-yXOa)NeY*=i!xfJ{<{@|e87C1wzy3r&h)(vex1_@7=XdmXA93sGDEdnLy0iW0 zhtPAd9N;H(u49*f_Lv)&X7rJ9!T3Aq28{nwCKPPKS6BS^Pq=!!(AV?)3HrBK4wDN< zJ^%l*mz(Ep=xccKx6q@oyhJg&-ms_K^F}-RYF_+3bQ6}p^ylqwIG>Hr@aG1FxF0Kp z0^FKL#w)dta}U*M-_!5rywCJi3k7(|Iuif$0C!&QK`-X{ltDKEo{|MwV}$}dWsk&9 z7;|cfH_?Y07!OW0@!%b-(krh;lw}-#JP6 z{CPW$V=ekoY{#3Eh0pKn(bqGS^E&D#I)7aLAf}wx!MolRI?t1?b;`2baV-lN-F_?j z7R>*~Tf*l*mxcKkjN$y)3*Lzi7_a>uZ{A}3vR5hRzIqlt3BT^DmwJtI&XX_R9z9R` z(D71C@Yi>Q0=!fkiNEJgIiF`~e=igqJSl#H9tf15FSK3AiYc`W&Z z@cI1$=8utc`EBU@dS@vp=l-xgh_^pr`~!4yT{rCm;q&K*=sEsey${hxt~1fUQ*z^S z?2o*0LD#4#=g(&@|C4akbz>enIi3gT*YVZW|6A0YU;c2k|2UR%KDR0SvvAb&foZ>@ zoX^Ep|3&CL4p*L===GTQ4XyC`^EaG_M}JK@%a76Pc=c|4opN43oSr%Q`r*SjxO&%p zG`e2qHq{u+8F#(DmA^teR5Njdk;VstXUT>bW80C!wJ z{B87cb)l2*}FZf;bZ!q5XAHwI~FT?nd-%-xzJL}NN`Po%(J35&s zOvvbYa`0`+`CPaOot&3k@f+TuoX>@G=L<)DUsd*dZeD$`VD!AYi%#C}zHsz@Qu;3C zeE&7{|L5vHpq(hX0FLM71$as5y%Ug*fHdhPl!Sqk(#!;kAc_~KG=&U(uJmNAj%6nN*-an3wuVk`T8Bt;qJgElXZrbcxU3b;O0C$QMEXye$#e~v7SpV!~aM87x)uCbw8g~ zUHQW9wvVf!<}Fiu*z=jD@2c^?&4!jl6%$#nBhR8*YQIZ++xzWPJI$-8yb+L87n8^Bb zh;g-^x;|#?-`|!C& zo(|1bKdC>`?kAO7#CdKIS9ny6=NBVBN6R>8Jt+BT)?Qr)+e|dBgZSGWl&7C$`yaT}!+HD{K6Uc&ad}=id1{RFcY8Wdo33iV<)+#D&Dt%_iF=7} zHS%1*i?F?UdW`k{LtOVb=eg}oyp)co9pAz8vYl~8O!&PK8Q*%~vK~7M9ctw7{5?;Z`vk`C2_GrA7;fX(tbKal6foC(k5MG|`*iT}@ z@8wE4d*M>finv+M@9{49=eUg1PJI$zx@Vko-yWD1V?Afzjmvy&0v?`k6F+pPR_nH@Dy$^f=PmIsU6S?v7e$g#F4cn{n)UM0>pU?3OZ12O<8=k6v zobz`~m+%&b_r)bo(a-EWlX1!OE^g*o>E>yVn|Wdf#5vd3gZR5TKjo~AH)1eJb$| zxYTDRT+R>4Bm13!w`RKB1Q6ee9UQ zan9ehZNuf~I!_DNlPt1*H{P1KuDDsAbVF306H)Q~aVcl^#dbMQ z+ClQjd40u=9}^Y-j~l-vDn9wJIOo0pUAVNHlZX7}@WO20!V4MR3opoa%B3;Z-^DD! z*}bO{E!5?2LJW$gDDF4w1~cuDP?k1-#q`kaNE^-u^e zK-?ibzm8|Wt#HZnyO{_73@?V~ULIq;fBqdV_1+vWW8?{rjB~DA^KiNTNc+lhy@yMl zOHp}7;v631_SJ9fa%lmHheefQNVba6g~A9*W_I z*~I?{*BkGVnDBe@;*apVcq#lhKBb)E7nZ5}`m9Hd`+9uw=PLdl zZpM#a9_PG|efFD}$a`zV4_Kl4?fzqSzb&~k&Uue{)bSXn9rS*C;*xg<{wtr_8?I92 zS$M)OPnOkc-J|_UW8H)O{(;LlRrHkoJmuRpYF?D&TYFyg0+)6ziw`#T+kdS(A9vv9 z`B-e7T0iW6+Fn2W6_@ce$9K#__|)b9^NToV9kbAx80-DjrR&vw(=}YyHJx}lPd70B z@cR?bGXCg1c(;ve{c6=YWBn?`bE8dh&N|4D?_(nG8{?PoQ9Fx2ts_Ch|TudDh_D`2B16RwGaIt?IenjElzeKH?wa z>xs*H$v)os+tl%Xi<`&0dwZPo{PO;fG0yW(UC!w{;+*H8`!B~>?_Iassr-|lY%jh` ztv__QVy{0u#HHNnuEtpJRW8}BuD_@7@b#DS58R{5^Z7NSJhV%#uhh6Y@VYUs5+84G zobz6LfuCa{-)lzji&-Eh8RpeL$6SI9^}p!MEd`*gl7M)E;6Uc2FH}@!Q7n5ckaYkf8VqWm-BxYKFG+E{;+xu^472RbCBD(tl#~MpEKfj z98u%a$=~d8X~I$Ud}sb$S%t?jF6_V) zxZ{IdcQzhV^Ok-0?Rm>-T*lQaxH+zFJI*=)zkl!n>i}*Z5BvT3M4U5TJa`xr`8x%C z)k(GPx8;$&?$`R1dM?xTvHe^o_^n$1O!>R9{z;z8xQqig@bI{Yk2|f_Ri^wASyz$r zEXC#id=)PDdD6b}J;NJunP+UpA&fzDF{PWMK=dJVqXFP8uzQ$Q~ovQw)eVs~vPOY0IeQK|p9l&M&wh!N{^V6S) zf3L>p!GGD~bH($jp3D4g*YiXCD8K(JenjU9@%-ioH9oI_*}v~SLzkn57$qK=kzy~KZ)|LcpKv1iRZPhQ>XBD_;OsY@5yl$xTV(H zb&?L9zNfRpMgvLyqnanpCpgtJj?Lo_);U! zX4g9>v%TK$an3q>Tyk&td%UHeY{pyg`yKJ-MxI1}#5vDt4&kE>pMlGEh!`c;{C z@4?Fx-x$}|1v&5j#mD1w@NsVW<#<2(SDjxOG8*Smi1kgps>I_m?&|if_*~5&uHfeU zVK|d?(q%Y!}=e4WwtcDlH8?t>2mvKVJ zPsF8uGG>m{gXI4Tm;Khp!~3QFWByYqcp8~J+;@?6H(5!V4<>&8p|F|XsC^Eq)guVW6OUhHx z>-VIMVcv?T;ZxU7lUTo}4BOXo&>sw+?ejbDC8W(|U#CjM^E>OvdvLEC?;(Hb_-c&+!M3&r`J_mVf~^*Zla>+*k#OF7=n=XLVwawZ67o#z){<9c4Br;n_WWGu8H!7Px`)ek zMqJK|x03mt`R$@2_WbrEd z^JTd7UtOMQ_n3iVUoUXkU+dyt>+eLyr1CrM z_Z!|>=ck+x@vCgtDdCO0XO16F?RVaL%v;hMc~2w6`z>kw&N%ZOuE%FNu0QdWgd!`Jh3eOy)2ss6dVwB0|C;wy;DR>o_+FVrQy-|0_B@nJ@uU-24jS1cQu zmr8jGX7D@X(jt`}9^>YKiqVrHc9W(iz_Z|0^ z_d0*appWZcd?sp>C zz1KQ2q{?#^|HOz-kyZ82w(r>eb1FWHxGVTb9UtQFo3g3)ZC2TC-%s%g#QlQHbw(d= zhBy39eRZtjjl361o-ue^;!fjjjQBhFbhZmr^;&=D*e|=^xgXw(_c7vs!{t7-KsEcm zvTzR7j)U-CM*MPI#)Z51+lK#y%lVeMx_!MUn3HiB?}L|ekF84i>N9H++a`~Ngs`qfcP9^&-gUh<)V7#syFa2{W zUWe@yxOv}w6_@Qa?|Q?}vm`!mZoj7z-X5>Wr!IeYJTu!X@l3AEekbD+cL=ZGy5u>9 zCt%zAp4a*w*Y9yzcZ>?UcCOuj~Dm%%hI02W}qMWV{w}`|$96R*2^m zxYV=1W~4qP|07)5D>H7kSMI!i=e>@`cus!q?3eSd4ley+1WvW9`X|qLdyh|fT<+JB*N)t;iRXCJ@63B^ zL~w#TcoJq6eEK#5<6OWt$1S^gWi>^DIjd%x-OtN3!b8DAG4N_;J?F&3S|0ghUK^33Bo)M21#-$(B#id{C z`X7xaXL|{r%ynt^PjNXfHsiYg$bRqO4RO!=k?X0{Tj{s_PCsaX=Wz3gx4{dsJp`wF zg!lUiUX1N^cu~WT;nM%F131m^If(22FY&i=IiGLiQZ8MdY;XIWaU^SFuQML&{dT~mJne9^JnM1U z-&$PiRp+^bOa2?Ung5OAYTU@&Brww&+g;Wo;v>RQhulXvN!j7 zvKih4m*cOB>+7=QnTSif_ruM0UysW=##~&F=Mw(_m-fAY>-H5dTw2w0h8A``x5XvT zySUCHYGpd~Kz zz*4P^ae(ry#ic#Q;$}O3i%Wg3!p(99%d7p~#>4v!arwX{E^iyVoHJbS6y@LH(*IZB zy8lZ(6sn-^Q{uO^?^8D7(te|Hvmf5Wr5t;4v)>l1sP2Db+S&KN<8e7p8{y`8x&xQ| z<8d?p6I{;61GsrU=BlLH{V!a%yOh5TF6AlE-Y(B-T8(E-vlfx`SQ+*KxT{ufpX#)A6yD{m%R7C-FRn=f|ae|HRGq?e2P^j<$b+ zHzU3$-qgqwzls_sPvDibQ^7S{4|cMB3NG{QTDZ(xbvb{+rTymPl?~5Q)$cr~zK+X$ zS>olq&X3Fa_yE`Au#ATta2fBibvEWvG~hhf>qq%1yaMs#aj6fyVPC?z?_xUghoX4ZrU#_0}Gjevk^!&8Kr*)X!90 z=8a`>bKbbb%~Lxn&sH~2o2WcjaXGF@xIQj9-oEdtex9XAq@T+;xeu4~r8BP2U-8(Q z>VAI%KEo}ioVcIjGh!&`hhEQgKBfF}yxD8}o%`Nzd)m)o=it&$%Jz!%6N�pN99t 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%0AfxI- z1g5063u>kw2Gh8TYk|KKYT3XLhKws1tPVV`h*MaMr4pnxt6GZZpwghfaN5g0i}HQp zu|-{_gRhH9P+2}7wAh4ID%b13WL+<+UEtB2K!!adLpm`kBRUaOW@;Mo$r$>Alr{<< zn-ffDim|;TTf^hnlSODDoM(_J4m@3#!w!onO6_q4Rm`ovP;B<>V%0D@Om)MX)f^q6 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

aoM~+njjCMC(wk?va zcl*)PP>%P``c6F3TboF&+!*T<)r63<7i#Fvu3T*1DT=Cv6WqJ8Z0b%-tU6|K;q@w& zCHyr>C&fcw>&bO>_mUzNjqa(oIs59tsgIw}UvPf${j;ef03~@XD(D+zeOT=h@5xCh zLIR&P>KeS0JlJ#xj7p2bfuWvel-$Q9am8@GA(>^r4>keyHNl_p3Ah%V+N<4ssyYB# zAMEQ8wx3!^{Y6vm-~{1YZu<8UiTfFAQ^3Zf(grop)9u?+_)bC-qm*T2v6EQ7B{;@G zuNUPb3Sb zj~t$-IhsIK4*(Iw+C1*9}afwSpY|BFZ7d#eb%7*f5*b@{lK94)PC<~tn(W14I# z;Rx**6gpx;YYP=_a}BW5|DU~g?M@>})`kDf`Fxf@_mAB+?!orh9NDw>yz_;Hpk%Wf z0Ru>G&#!-oxjm!=@I^MW*1>nV08Ki! z$z1rw@N$8cuuv3rJMx_TVDv0iL`ns0j!-eEl{rGr61WuP6J}Jq{;TDlIbN^Vk)5>6H{OzWOLM&FNjoLENHC&t= zBylLiJ$7UD;CofKC7_<8-j+~jFq&OQcV^(X3M-9OA^s7i!*IHZ=Q-H>B4M?sHTg=U zQ(v}EtAH8R?WmO4N_8vS(0en6 zI+Z1QVjan@cG^M&2|-e7sVhQs6GV0(CSvL=KGHqtP0Jb+Up0XM^R{(2M8DM$!g_r@ zMRB@%TI$}lbio(`X{D^)J%i~OC>+KjlgK3 zzxQ?lfSvJPWkW~z(9v0zs*lR{>mff+Ut@|#^kX%Zf+6!l5Fa+W0xeYOC)Vtp^hs#? zB2?!QSEJ>cUt5`S{9EhcLPUyn!-dR!lsxHWZ%$;Ijd4b2-@*#zvANhi#8B1fJ=ufR zcs)xEs&HR|zPJaTh?>|H@xy34QbT-^wAnqznWiC;7Fpu^jV5g-zSv55L}08m=DGqj zWzI#RQ7O zQr7!RN+*&2epuf3(Yf2ym%6sol|_gr{Sw$)<)^OBbobHbQ+qw#;3$&FoZVr3N4( z-kK3%3qT&`8{bp*60E60)E+?caa+FM1t+c)>CG^2uYX*ISL)Knp^|pTG@?dg1NM@Y z!Kv+{(DY;1rimcBsOYYN2)fFQ0xPH@V_KuSuRmH9*TVT@>-tzUh2HDLKuXaF%v)Au z`_s1L;41g3bYr*H20eI2;1>)_B+oOIbv=FlNEyG+4sTWma%#89UCdBjKt(tK`>HC) z2=l>JK}Psfq%ESavZ+|?^)U^3_Ou>Iy!7LkrR+$IOV6z$j&t$V4{N)y1FNRaTkJGP{ zjhS{%xs;x@gdgya;O?DJ;wzR!Hw&Nu`NY%<1PQFSWAqpI(6Q%XmE4hgu4fYFl_0-G zS0%Lzl`(GV+fXRwpK}^7%Kjc!96QwgCaB;FKSb%m!1EotpL3*IwvS*UDShHh*JMoA zb1(Dwg4$-7oAfSx?PfBi-Wn@aGu68`{~U8=+q~G`U|-yM162(aW5e1Ca{usf>{qaX zOXq$iFCriO0GZ=H6VOO%0*VP!C|LG9%ij6+D=6^KF;4LTJw<%z&@5$(1nu2~>QF$) zNbg>6pKPTR6;sIDWf9y%^&pbFiw)`ycjNojX0!U{y-$d!dRe2Se}$4Q!%B69KaE@C z?=u&%(D+1Qeyn_>Yc*uwZg+rCb4=sq z1jBXcJt0p6v3CL;X}CoXe9GL9=b2pw{$345Q8vlDXKHHm=9!+CYC^CrPxM!y@ER&V zGbnKrwA3#VR1*dWyxfH2zS0Q$owq3u;t1s!Y;QPLdHa|L%_+ zJXB}qUqD)sV5s1g=qpp^mAx{rjGsZThq?i9Xl5^T9NsBhuhu&ZtJ(H1wqIA@99?eb zUzQWpGZ)){jO`0I{KC_=*idmO+9l4$v(;1yHhKyFMXKEB`%v@4zZbi&s~I8GgCIo* zhI3ooryhpelK1Ab`4QY&6q;${E9v)aDUCxiElJ`hLR?fPl^b$maW{z<|M zYOsYRj}XFklQ{&ZoDR4(o2Myi!A=M1csk_SpHR6%_BfL4JN%+B$9_m03zc&9JQ9@~G6eCwz~F@6^-{D4*7Gan?!X*!}m;~v%)c={;FfF^gt zBPzjX%IwQ}uVjf*ebW|Q8DJzlJv^X$#b`<%eX&<7;2s}wMDAjz0qkF4-EVL(te$q` z>3lPNTEHk*-%!=;;fL`Zx-nk%bNEaJaE1c2P;lc<#NcJVqB+p zv3zN^jPvGC^J7Q5JR&k8SU<-fyMk@QIsPq*WQp z7r74{>RD|e5~!=XK!o`$2t*8Dr>vGojBezIGl(ZoHe`0Pj#6-_KN#|8C#B7Wsm7zfZ5viNo-PlLzH9uZBBCOuW7-CIEOwa@C2e`QTdFa zsG$AEdqiIX2L^R<5`DI|o8FCi zX0l};06l;sM{feI;I*S{N&nLy&%+LM1B;y{oGK!Umc}coCg^{Mw&G|Y3|ojgl)zIu z*{wF(IgtgxIaDwU0L~#k?cr(+*R(&$APrrqtFeit@hQ~j{eVcFNtvrZ`QC-hx7xJ* z2O)*M{b3}54Egjl-gEhCAO|&T%!Hn9S9t({XOQo?5^hZIn!IFRHWXe~SJp+vULXSAFw zwDi(sE*kw{WE~w`Pk@Yy)o@9#H^%u`{gaZSaFXZLeU5^~XmCe(TCqN$6*G?C>e@^4 zX|l2n3gI3haO}veGt&U*5X0CSZ4s_Bs6Oa&uM-R5cmFkQ% zp8hpaDK+EC^xseOO%c0Ty-Rf|Ep@6GiF_Gx=^farTTVwh^Op0KmI%3*k_2LLFX`$c z?F3{2+*}a8hq!yJ_=-+j>L(Xtx=$)Q>m4b0+--~N=ss3m*bp7(y)E)o5am+cSK()P zD8}2T^_q}Eqb>ZHQm_B8+OUGp{R|NRMW4fSr{`0>9bggy9+wu|F}|^r;R*pjCMD6< zc#>kq)Xw&SX+MWyBVN7^IX5CvOu2u3ntXy}oIWiv6Q>}I(>x}FfUhTWN}!1}&nPFA0wDC~qc_obliZDA zbmD#Q%Fx+lt2*9tJMEU}S0I`VaFhu@@+3m^ixuxF4a%@Zpp^;5SZ~m%h$uwKF{7n( zdQztvbcyTwE3^;NOth6uEKy(KU*N{{&iPBbJD{pr#f>PiSKk}i(F2G6F7CHyf-mgY2Z zwoH_qJ73*$=K!#?5YeBP9>8)@d-oqFjJ>4nydp`7PBPEpVpR#@_9Q}YCK-Ux2eeKo zSb|^xoI0$yfacaOOg7Q>G`|Aj5Ro|VIA2=2zDQCblJ3QoEgBqRl$E%)<>!2c>V{FT z=o5zfmuqcEG5m*OGJ{71rAj)OYgC;AHW{FaBzL%IkK85xyQS1*E}6(L!C3RK0x$|f z-8wL1!gYQH0xqX&7>fFdO{Lx?WoPgVh6ki&ncRwBNApD`EwL#X%_7MZpf{*%shLjU>&?KAXbhi;ry3>qLnO5!5 zJdn;9b<5#oM7ZD7NwOi2k<#!GKid517}xy)-4@4gNVXSG?~RAnORrrt&?bcDYYruH zM;o=0+6&5PP@#oK$-B9FXT)U!+O=_69!S7JjgN)o+RG1mGoqaQ`4QW_dSOm>k9O)hz8Nno~z16U5bE4Fj zoB%JY%f|{;DkV7V|Bd7;8&7Q6|GV=uGBFyiX}d!d#)0@Nxcg|2>?$sm{nb_g5ruW? z%kadc9*iWbAYRETh=gxLUaX@43G?(0hN#!eznLG1tZoN+3o`JkgN( z7!uDEP^AGp=*f9*6RncNZBk#&)vAm0iyv?gJ&9lK+xq#%cR`(%t9IcM8Sai{$tgWN zk#7MVFwB#v6n@79+WK@*>`NF0SH~`#b?0z-f;SX{tVlI@(FWIh-GnIXvHn`Bzb<#h zKCX<7+XBeTCtan1EkMpU*j;aJa(t{kj5amsOf%d&cue5JSa>km-cp&zfRgZuW-GGE z@GE1fyk3*12oJvoboj>^{mWf}j-h({{t>nHHP8`V2jJmH5jifSougUj z@a;dhYwnXuyZJkIL;ps{qwe?9w^)Ah{WuoIBD)>sB=hw^>ml=gPx%!?I?A_ueO0yF zIakLBzX4hX?S?dI$tM6NNeu+CX-A#pno@7059I?xv#d;9PNcs6&@sP>vVZwqIug0nI?_pM*%G%3^pi)el=Y`buBMA^ zL^U}@aP4F?X(hgtHRTBiEz?R9#7-kjcWtI{k&eI(DBi(c$DA!bls7RC7)PXOAazcMo3(+BhpbzNUrabxV$S2}M%R~hN zwS9xz-vlk(quheug)}$@K*;l&En3&{!S@CfztrA3bBhyuxGDumd(oWYNQOF{Tf2Kl z^=Dy{u*_Nu{PTN7B%?-=cGjy_fnjIDQY*Ro-f5o5Y~4G}Uj+y;y|JhV8(J=JF?BJ! z5nGpwwdlP|#1Za*EYJ83m>>oNtLLGoqgL#0{I;{bNaMXD_n8cA4r5l=wn@ka)0*pk zoeAka)Ittp;jWRnd*QdtyePHIG>zdZOIFlMs4N3}whs$^51%0crRSJxCG4l)u77WS z_U#gDouSh%HP1wMa=M{aYHr!5qDz#d@=NOl9=a~NM>M!Qij{!c4%5 zR4qr2p?-dJ*i^1fqOMRl!W!&cn+4Josj@xtS0x4(ZLNAFQu8iv;8Uv%KoIR8`&6R= zv|mK+tG3KEj*{B2H!tT|3rK1>FQ~z+dP=aybN)6lc&`HN!D0N_X+lF87jWT zpN<;_Hw9V?2brDm(_iqW-GL=e_qx~RX(--Z7af5yQ!SYDyk8JXZlUJFGc6}Nwvi1k zT>8Gk%L-p%<1R8)ZVm$VxS&VPsdu4g-whdJ zDQHF-tkem4ro75$i5H0V~KdB!L{}L1OKQ-Pq)@ zXMu-3HJ8(#|G^vsE>7SjeW5mNjd4I{Wb64rO}1^8(Wffd+zF7D^#3NH?W8qXW4yMa zt;milE&7+)R?4Q2P)c2Gi$rS$(kzJQ=CNVU6V>tSaB_uf{cnyzual z=ZV7r36(Mt_>y8VVxEROOrJodM=ZzhQGvW>5U6Q?w5i?|uEDL2#+8LaW}G02VY3BX;Kogc2;FDt|MXqCR}fdg~cnX6B#c^=dJn z&WkNZzi!5p9Sx6#Q4028M!ljD^WF=3vt#vwY9pro3%7gb^to~~2NXlA%)*a`v+lDy zo=7{LOuy22U82)Fx0;%Qdoi7CcL>ApkSo_Kr)>4{!zqSCj(3~Me7B_@$sZs^g~rCk zBs7DUKj4<16}!oNkwQLKUMG-$4gHZ1DR{CQRkduN^^#ce&2L|sz z{GLZBe5UR8OvaMY@w+*Z;IzA49Qp-1Fpj5_wZ6mpu7V5#J27jHckIv`*$Nq`Z>ZUq z1yJ54^UP<3l}Z!G-*(0xj49j0Oc`OyYUFoCkC11ZNm528Ehx;UR>IE^GFT)~2wU^}P62OKu#XUMUYv_*$?) z7E0{dMHpL``;cO#hCSzSxTsX=MqMMOJ6SGQ&^HU+(O91D`wJ*BZiM6gWcnx1KmRu0 zeI2{O=U<*Co5^xlph%^KxIv5_)cJh(8CmUTly`lH|8xBM{RL@JSt6eEL}c%Z$pqai zdh_l0arG=_de83{g=kx`-SlqEGn4Ih{$)9#2dG+TaH)qs+pbKQG%ul}BApIY+mIc1 zbh;2l_H>uUH#yR-1MPOc1ajsxA|2@EV^e~-_0+XJzjF@vq1^%~aX0_+w0hbSQNqkx z7MsE7-80p_@?WBwZculDZB4wZK#~02YCM_EHn6dC>Ib>cC1gfsm96D^Sn$!GS5cfSF%Y=XP60$sg4mu-95OMBcQGn*Q!r}(t6i($cZnT$wG-0NR6SM3MT-m&4AB3IafHP1q>bDXR+ai z`j1&JKwHCAJbI!7I0!9O$dk4_B2c!HO%$x)1tV7>uvfcH#jstMmpfqbG{oA z6mq59bG@_s)n>E$R?Nmb&X6g;>G>NIZ@P>J1Kh=O@<@)s(f3yh+A%z8AMi5|#4GK| zyJ8gpQfM~*x?0SN4PcJ@{K&D#<08iM<-=+)LQIEBch!z!Yv0V5+udY2E&6BlYWN|@ zwhy1qbe;+?$zwI#hAKhq-I|r*towpW$zoH?q&TY<%jXYI%jph{z2JFSETT@nY6N)i z;xP(=z!QCGf9_m|k}NWIG=09Wf&VK`XiXNu-K;ktFLk3xMZcKMr#o!uGfg{@2Vrkn4})6Wo1mWwm&M0l9DRR{^~SGO>+jy@ z`RU20!AH;lE*n4ex>yW%#iR3GSL z$q0SkcB`)zsfu4?wI4%n#9?uw~B0Il_UvT}P^c=&`36RTR@kb3Uw0Ubx! zM^~j8kI{*@v|5)?CO^0zGJA-V*XH!w@>T! zYO^z-WIgO3nt|ILn)y(Mlo6cmqlUNYtSVN`A&pqXCxSP#uM!gcjhM#*VraF0$%6cI zZMWP#6oF-p4Am-+zo}59o>Q`Yn993E7lT^31_M3U4_5uR4Ps;DGhk1QcB*K+Q8JAC zea5;o9p_beYW(_IhnPA*v!Q^HQ2N)C^?LDLc+C)5UTzl?L`An057dEZ+1?`F7lPWq z2%`g54UU6#WP`m{4M@1!YB2T8kv$edtbhNdE;ksi20K-+WpIS9AM@!LxeN$@52sLJ zBC&djA_~=C0sUn2B8vjy8U>m?BPB`%e|D0xokW~IlVW9bOtu!>l1jl4*D?5&yIK}N z4Ta8Zf<}GyrGWDbSTJ5UsCAU`Vg6}TK6>Y*>%j_`%vQ_AcVI#Xx!p$%_iVrBOkY2@ z<~dI13bgz<*$v;4`DnCE0^n?Hb?$J7du&W!Vqs+V`qTA#Y-|r$-t+BxvV&y`uc5I3 zp#I_S;KRFrEZijw3G6&ZVdo)<;SwTU5WPb@tY+fnzmLd#iWQqrMntV{68i4OVs2N~e6o$k+;_daL+P$>Pn%Wp|L=m`mj6 zneC;_n8VgAtTt+pA%TM>^8#2o>-G@0C8mm8v{~^md0On?&p?LFZt?}>Rt~6l_hpJ0 zH~4a8V7E;7ym}k(+GbJbQ@JpJ6QVam-?2%@IIXIk5s9nsHd;G4e<-p` zIBg&lpXYF|&M_qfLroh4OylgBEtT%9k3l?^>D=+zo4{GZzBe{Un|I;4*cO{-m_!b- z=I%x``_$ukz#5gW4X_5=>fJ;%F@-F@JyXqfOfA&$%};&m5LaD)uj{+5mlcUoIJLHy z*(??ue8byoRzV(bT#Lw~+<3^TS~%&?`b>q?C-eKkcKs6d7>`PV>mmJQhZAI%gIjEM+3%3@6#7z11hn6*e<#9q6AP@6D1-KlzYfI zeV*1D*B%X|d#4(jg}lr{4z1IKXb=h1Sj`P;AZe3Gn7Rv1u6`3VNACU}6eqc+qTfnd z$Yq)u-A21D(~N)bm82%FV^gYTm`1qsoTnY;{8@^D`(CE_-9XsNLZ?WIpM8~fP;f#X znKb|0FQboKrKOC%OG+LSa=(?p4jELtlffmjCsUuVr*RZJW72@yrspM=&CABa+*tlA z7(z1&ZIXOv2?eP=nhB}PWdeqgy9AycXV{_$4G6Smd8V9>9Yp!kx7I6tE3c(c-Y-wi zA{&j$ZJUe&;lvB1#pS0m>16^|thiI4`R=EJ(7~0H-c*vrVOA!(>N>~GVcn#l4Glvj z#D5l)nijm~b!4zf9Hd|JPMTiy!a6OIN@j*jMV=>_Ne!W8 z{8Zo#V?}yHWI`yH7)LZ6`$#McOBcG6JdDJ{6xM{_T(zan^lp(8*Cp_)yidviA}(|f zpRRFr6GhQjU_Io5{f0v9B8?sxK$1KHDmWw)q_l5?afX7`Wn`hR!2}zYfvL|iWsT!l^`il(?HU+0yTC+A}==4h)bWf zKI^jnE8ycvI#nc3eNt<^(UekW+*h>+fd_+|B4Bx>>xbo{*Dn)gSYgg0sALcNAL>_s zC}-1jtp28R;p19_SjIJ7?}7 z=O*G#N;X(q*-5x}X7HVnWwo>?FR;FbbuJeEl(BO)g2+r(tiB#cF?rLwSfc)(g8qy7 zBQ+&>9Gv453X6J4k5&Uj>qj!_&0`_@)k=f4nmo!pqz?mYF~6tKe7GNOG3557aP4m? zCjT;bROY7dZ;%qe3D{AYh+QSfauCSN-lY+T#_I;D*t?v~sV_l+ByUazAB1wTB#Cps zs&oh7*V-xXFQ!PrrLEL~&6RScFMnng;GZgG6e_^wn2O;3iK@JT`5{3M+O(fce2CPQ z$H|`s>lpH$zV9I&_@xjJ+imS}&hn(JDrMkTsZk!LO4!a_ zMoB(-&a@PrG*nU)D;Be(o;Zni{`eEv@9{tX{`_&i94<)K!{9%szwXH12Ss||!Z44B z=`I$}kN@|vc%(wm|GPe$->CnYUjdaS`mUFzbHNK#5OtAb64}+gh8QRE3a4=YeYO2tzaP`QRNG8d25xqPPd$~ zG+ysEL%1^UKvvK0h?-$mNl{e(Y^WA*wM6+W*W;z@Qk<4&bJv<`cMZYB)sST~tLeg#fo0{J)*Zq)VeP3GKRkjy|)$H=z}tLUr~t&iLm@aZ4XeExbbxEc3C^VhM&;QBM$7?ruWd- z%UG=lfE&T5IvxxoezM3B`Zpl*&IJ|aNn4P5CX#b%Q)tb(Uco`PB2-W1)xePY$*K!9 zKdF~Cy!X&5EOYU=IGcI6##NPtWpu~R6HH)i>kS3()vKE#t4w>e{LM0R#L939Bp9O; zL2$IV{6OoUPDH{Hc?*3FjhL6ksmHi145p$Bh%|}j^q+OL#Ok%&LgKuyp~vD1tRgI1 zPJYUN$Gr>RcVhzd0>JsNbnBOkFTBGKippHQ1e zdZMKrU76VzHKe2OpShUwL-EafwAV*78oZA7fz+!Kw#dTFH42yWntA3>z5#KuV-$+lEL# z0WcK(#vo{j_Yx5q7DyJH57TW`V&7>pZ_;9DX%RZ#K`BL^FJlOCyJ0CQ;*ST%9&EY20di1Zh#u0y51c}r*IjUU>;o51>V55*p4w> zTMC&@0Sgoan36o$W5;bUJ2?u??z>#smtrl)lG)9*89I4OzFK5+^tjTJ{3e2M;NA^aPC}3OcBX$X$(r z3~nGXUSDcOE=%B3*aPL1(75N#?GTuQ_(j@dN2D({bEmZaWN`GjMzsmDt-qB+Xha$< z?lN90Ya=n?m0~$o`b$=_HDQmjK&CTEMNqTMlu(&FLy#Twc;qG_n*_J>Wh+!RGd)#!$>zo6=B{P-`g zL|;e8mJE4N33Gtl>B=OkS?Y5!D~0Nse@Xv>Ls%H9oAEfI0^c zinPg7cQF54_YlfX2`&Ryo8Gp^cfAt6yHCHPSo1fTT6dJqL)R@;&>iK&CL(WrtU^$> zMyiL>5$?LoR6M9!AG^Dp{PBn;-`g!3=C3F7jUAod#b!0#BJvWU+k~Q#gLQ&GKsAG)~_hxLnoVKRuUP#jw@a#Z9b1lt%y~KX*N)jkUO9 zkWr{!M+Lhlqq0J6ffVR66j`op?^J$;weY$>^q6vo`Py@WvMq3{k2U#i*xN1xxgq#m z+g1Fg>|F}F@~O0i5iT66Imd(>jc`)}s-_3JyH$RGC963nk~EGdvmnLN6~dRr-(E{2 znIq0;gQZ)eMKy=bK#P%29mJZ$%TWAVolV@&3%cZQ`_how$7u@HyknWA24Qj}S+<~?ngh?5mwTAKH5VScvPdmk zz6PP<7UcsC&Ei$04BVJzLGpB~Pee*nyI8j5UZ!N_?RtUw)%z!E{ZcR4!hUwF*ntnD zT{J9v%UbqBFjnHc;?)!C$>y8s(_*sG5YqT5E=2Ia#tooy^W2{3@w1L@%}CKM(BHV$ zI}WGMPL$ZpDE;2+NTNLm>%DIEmvmr}qT57M=P4!rG|CfFDjz?-N~l*BV!rm4IyjZT zzyNm`R;X8RE>Yqbso;fX4-g-!s7ht|*5V>YfB}JYxpZiWnzcJay|miuFfUb*IIjW9Z-{3goi9+)U= zqaE%c!pioN`vjV8^M23<{PAl7FARB%xQGmmkKpFK^IV;#{w?Dckkk@wg7@prPn9jD z`nW5Ck91%yME1ixc$UR{eS`ft`eKs0zSD3Q;ODj9M~6oK+ZECx-T1GljUMJPAVOaJ zH7(Y=dK*WTZuj7-p3Qgj6?zBKFo)$1ouzNlS9-ZpO_q3J>(8FwFA8p^t;hn;_NWIn zwLbKpVLL_B4(qz)?$JD$j2LG`8B@Mqk~jAJbR!Ur$=j)vjWp5gLhtb6yM$+AEF9oB z`eZja2^8T@QA6Cg+!s)Ke>&1It3CvNl2ydpiDl@ejF1SRL;Ec5MTG50M86<)1Vx@kP(}QU!4+Mm=^RONaht-^=?(^myckr{K>4&!=w$p*s1#zI$0?KI-jgUp2k7zUVZNLV zrxZf$^`>7DlhJfAg@gIAcXM%Zb$xMhc71+*c6)i*yXsv+8-Ue5((TV-9|uj)sl6#J zI!0eAaJT#E6s>!vZ1Iz|uNs;6sO`*Ws_aj8!-pm5?n4M)AICGDqFI}2Uuaq#x`v4D zy64>z`lgfVSIuIa?xGspfdFCRsfNw&cUl{~Rz3aE18==r%%}5W>$TOx(x$B*wyyhw zQeKtmfyfOO&5r(v^}5qQP=;F-5LaJ{CC}-wEcOE)g_4iCL6eRw;M`0BMlB0)vqtK}lM^W}6?pv^NCXxVOmf9<;7ux?q`Ee=_i zC@q!HpX@*fic5E|p6D*Qp%PKEO8#%LM6Wl)gcIGXS#r4xDn*jMA)R1C z2|$R6+`Y4D=3q3Oyj{*&Nv_e)TSGYd-6uI1L&jWea*;E-D8RZVn=hD21UFuT9idW%`Qg=e{+kv^Q*joh z>WGU6+Cdjx=8O1o{IY7E=@wR3kK?@*vxch1xY9P*qC6BK+~s#fB6&^gabw0OBgY3sD!Uy2KEK7mL5^DW3)xIEm6eV#}3Q zV-y>lDU5WprnzhWn)Xx-ALZ|teFz4I`17HsApNv~#I2>tkwV~-9DPvtL#gjGN&{F5 zC8ZzdrAOaC-v2L&npdDK{hv{_xFk)IlEHv&amAt!iJw)XkA8mzqXf+>r2~XHl zY>LFXN>IcyY=rUQ1K7KvraKH^0c)3y9m3oWc6zTTdyx<}wP{xRB;EO}t&;sZdN%?S zy;U4;`LKE%eE7!#ey%YrR7^Tw{aFk?y&+zE;y}MsP@@xu0@uj`AH_E&CdH*%l{n;y zCzgh*9xF43iZd~{LY-u_dm8sv>3xofCBs!w7xUF_7W2#AL1^jpx;zLEv1l8QcNVk> zpSPnTNaywTX;HvTAH92~i}U80u8Cxs=9%+LagD#tG2G~RHAnvlm@0<)FzP5+M%=IV z>kK~7J-8lg^=CYNCO15F%prHcE476&W(~YrEq9px>fh^qzUzHf@D5HgIn3U0)v>zU z7Tij1Tji7MbDQMlFRZpPx?`efL{UIV)n{KoH3bpf3FU>5t#PP4jsUF@_s~G%kvi%K~^(WSA@#B9i z=TmC0``h*(pWocr9}B7)t$2R0e<@aL%1hby`d=2SdrbRAPv~9fg7kSb#+vLlv#0g= z%hLps*<&VY%#`)O^z)$}xJ0$^2ukw3sy_DOs$@fJ|Gz$^AZ&^kXL@5=Vten?!hV<~ z4O^VeR~#n3hy$Mk|$Y$LJe>JzjNXcXR!%nEVO< ztM8eo8qU%8|53jhW0cNa@!&H&{hFZ-yPgl9`L(abjlfe#7gqv2kTN{P5|@`92hJm= z{4tXCg}-xb&H|%VS{)*9;w10)w{UIq;Oz(UShy%lwYNOm17E$k&sr_(ti{)@Ev!fJ zp>oBCNXQQmRD)+Ydnmwb;VXHk^0#KZE=C-Q4l9q7^{_-sc4c>GG#NPik8E(^FoM8? zW}a6utclwSWK0-iQ612J80rvhkI;;GBbz+(9gCh#z+ zGrZRGWbvd%!gqrJy^n#){eTMaUV0v7+nJNWxx4O~GAMZdqak{&drXEGssZg%GXB8h zivhE3x|Tz%T8PxecV#b-xJ?OF@^_Dpd?l@B(V3@awz<|N)EodaZ4vWZ0x{_|eY}L~ zdFr&QH1pIu;5w31GD?NCL4@N%FueepniDqSBsi8@X>zk(tx*~2&;7LoQu}&^%~AUv zR3uhP6u2dYz3KZgUA836B<{6l1a~}%0=OS$#lz%jv4f?Ldhy-l3m8FO*M^MGkk`M# zXDT(T8ku>s;}V$8f3FntaMbV-d1Es# z9so7e>pTF*Z?OJQA z#y03|<8LQ+1o7g`#@x^DO*iYJo;AuY(P-M2;pt@r3Hf_#(v8M{GlmuK66;TQd5c>k zB{;6u>x7z&S*RV)lTy77TUGW*naQ=eoR9)QW0jB+n2qlWF(JDOzONV+$<&~`Yj@N_b zGS!16fY7z-k!RQvV;+;K(G+qw6uCt$p^Mzqzxk?uPfO0!irhjj@bk5V!_t zB8%oHkkzBl!n7{*7GnD4}8eNn)B>OM9Qp?qHRn9lBR1j$v z1}Y$lLxpN`03YdrBC9v#Si>KDgVcqmCDO1_?>0jw)0$yG;Rw$A(<>^c)!}Dq;fjB` z(T;ckUT%!|R_nk9_SfMmJiW}Pzm1U`Y#zQH53w}f;}A7HVwYe9F#WoKG}n(~dHx-@ z2*BGaD9pvJE>i`P{znV8!rcEf^ulhx9vSq``P59YfbR?(R(N|!!G z{#ZSd%J4@G`;Vx#AWL0oEou)ouh6JzwJIFQHpbCP*JvN+rgX$lZ-up@qxvV3;b^#U z1khe->LN{L(^;OKVksQUh)|F-N>1=%ne;?Od2+<#!7!vIOL8%$DG7}p&%r3#7;NEL zy%wY$V&d??D71L=(&oBy`X0qlMIDWal&M3eUy3%1H5q(lQb8-VW?{p(!P?~8RDe_S z!Rn%=Ju*$J3wIi*c`?-L7-ST)=_F4=EQD1RVryOoUggVN*p%8zB7wJko@#ekRqAgn zZ;8Xa@NR^eORet)G2vJWlKzmNgtX6BD)WG@z4%p*Fz+ZCABk zzCn^r3KgMampLRD8zST|(JgCh4JJjG8m8b}AT&oYV)ylOe3@Pr5cALcFd*#AH z=M;R;f*swhbnaQnjw9UWS|Y!ZY7nt6qVE$axzwA=292R zkzX{oKbw~MEJnN7f7Q%nloWD<8?VlfZm(&Fq^oUsfR>Pn`vYI~5fD^Os!DeV48@#T zxf?lG=3e%i!dOZ7l89pmvF@@3QoB|k+Y#5%^yJ=-*VOLQPrhlMa-M=zU8kaJ6FH1U^aU*<4oM_&&4MF|wqzX1m#^g1QD zOxu-aJAiYi&9>t&UGXW2Ln7Z%boug=Fm9=X(P!#u{C>6i6Mfcf%eUcnsE^i(fRk)- zl4>i{gTS>3c!qXKL+`yXTdHU!W2A?d(9uovnti+XxC|l%q`T%J@n_zd_+II3&NS1Q z6@O8Nr~T5Kd)v?Q4iW0$LMnbzaf68n@WShH@0=IsTu?OC#?O%aiIq&dB1~=hof*^M z5|czQOY9D*qSZGb1UG4@ap!OTyawky0*+)dK3r71fIk*4Wsp^4-*{XVqD@A`OH;ll zkOy8aL@z6~GDJE4ok=0)(|DsY%?(N3pprBd{ZTqLlSo{djir`FiVCR7Jp3E7j$hN6 zk^#xYhD5G8`l$`^G`ojCOUnC2k)u6HfVWADFzMf~u~$rQ2## zv97O)JZ}r3z*91yrE8yS86*UUkUXchDWS+IwYX{o$#zNE#Qo~JyTH%A$kwXlM`hc3I zA;c7^oC9O$np1|qokb&0)ufTT`Cgs&@cSZEgCO1ezpDK3>T~oFku316NEGlqO%^c? z=5S1;Y;3(5E9;OM3oF8kiM$?LPNF5l36L0qJWp#LQT6PE>e4L?#cL$4 zkSy|vT+S$U^c#p6b8Xw%RDR`%qK(RMGO;uWAfN7u)YROuEa`c?twqa642S&*ghsE2 zAU$NtqQKlYFQ+Iicccg8sM4}$%77v9cv1?>KGBui98Tm~Aw&=Ltb8L+TdsS#8b)&9 z1_cRDW1Qh5iH;LJxW4hE(7_pgBeG?n=Gc6Z#2FH66fXXwo@ku*WJEUs_>W0^k(yLPDD~!7yF~6iwzn}+dZ|+{r%Ez2oSK|9Z_vpoS={oeAwto^(x9#_u=#TW8j zs4)j@IF~ak%_SlQG95Zb)8Uu`0dJgd?3OVJb?nRe9U9Ub<;(HIf-#vz5S_yPRxT(i zPLGUYeHjQnln4)#g**zK#J zkaZEbe+Lw#fxn2y+v+ouPKSfQAvbCbwPx%KgWt(-h^+Y$IGScvvto@-*ToV8K6IFt za!^$?T@PDjFT{9@8B`Ml*oR;$|NM;qp}MaxtJQ40fue?{*$=#eD1ECmNlt}JHZ(|n zH2_n7H9(x1Hic5&|?25}{18(IrhItW^sLMEA6mjW7+a^8C7&zbCrI7a{8EMe&v1iu52FIc(<9%cVSgKDD5~-ifhyD9bYsh z8W)tIk8W0A*O=V)hu{6(qM3RYyUcCgKrEGob`r$kGQF>+nqYt$BMS78C-4rCIg&jc zGWH+9s#$*V+Wwx+l|SEW?( zoGxop`)ChM-YAgYsq6`ViFjLVSquYd@pjNwpv4L$_j76JVt`~09r|Nm+MG)q@-{0q z>I@KU2G>@2k5ui8)KD}+t0m|tSTG^t+UzY-n_eeiLWppe10HsR@hV>Lxi*l|O%3OD zwpoX+yz%I}1{R2+;W}w=MvEO=;fIYXVTVmi(@~sy31Q}Cs8JG*)GHo_=`|rCVsXMz z_|X_4R_K~lYElZmRIjffKVfgtW86SG$3SYL-Kr6F=^_FlB%V7D4V}SPXEw``82_S; zJ`E%pDV!b_%RkSQtv-AMDn+-N;fE=NII2VI%iTN}SQaCMO#RP!C&J5ozd;v!wON&_m>P$zD~8oUwRXxwFZ zZ486=&7m$cXfnXWQimsT)JD?Rphk^#P?;aEI?w#b_;_=Y zmFXV8wNCdKfQ{y*d&KnIj#4IS@WcI)WOtCu3XLI>40jr2MKSsxg{(wi{upF+yuf@7 zm1!0Ld%AustJnAjx_n@>wXgZjfUy;)xFaVPrMVt91b-OtDLPyQzKapx9aQ5>bv1_1 zJv-QYNFc3qisR|Om!h@~SNSw_Sb0mAtvZMfdd=`sI;NZ)@~Y*No3SvY+xY-#TnFL26&}hAyXvrPgG1mdBvTV!J|qoTc3Tb;R|XXF z>E^H))DC0x%Z~tW?5o;VO9W$vCo_XKIgPc#YiT?^@kTuJ<-^Kv5p2AsfKEBPM+oz{ z){CPzqi338#BKuVGh~0W?+7qU;hpR8>i&O==?+dzf2JRK8{{&H@M=4V;t|ePYtd;n z2*9@bhB=HNSlMc=ybvwA+VS5=h_=;Nt7EpUmWzi%4QaJnvgADpqq?=LsxYrNxgZSh z)vkdDB;oV@iEp-(rJDqTTfr_xbZum~_6rH|&vtn z)~w{R#D?mk%dHkB23HO@dowBO!p*7g8YGzz@({RD@n_(vBL19OPc^PJt05pQAr*J4 zevKePed8S&kP`DyG?$JQ3SqE#MdeQA=QLImMK^|7HkZS3;n{edhJv&4`V~U6@j7_| zGnv!WP}8XvmW_dr%Z}D(Un?Y&0A}SuHN;hXgP}A?f(1?>_=3u4Y9bgLFWyKfCRcAD z5R>b~P|!jc%5R*9I(=CXW@J@0q=p^ zp^4nP=0V-Glp9BaPf##TeY`}6m@bORM&QU;`_ZRwG4Q4Mg0`@Qe1(R(Sj-JZ&ouVsOlLZg zlOj6M#lFzPT__{l&K!9~@cmCQ`SY%L*wSQ@kL-*X|55B-&!@Z5ZWD!6?`u8T&Cvp2 zJFwIrd%AxS+1Hp3ly>89FZzBD6%o&vg;R`I4-Z=;{!{;3e6);;U^Qe*qFFKtGg?=B zM{h*x%hO^vf247L?*K@6+!lxAiMb%>q#6@|f8CgA7WOAXc+%7B$$T?>M~P`#3GMaN zE0|gMg+^S+ss%eJ0s@zPpa98^)8qU-IMetScA!eO|FLFg&_wLB_bG zk!(Q;W=6ftdAaPiL!iPChC#j{&ljYDHrZ#j^o83{oo{wNhGpt**EzhW{_Ucl*hI{# z4$Gf-8S>Tr9?#lj4-%cDxP#+Iy8J`D%imNt79Y>a_yf@DFT*h_TldE~W<9+`A8Vu2^bgW<<%2U{9FbrEKiPSd zMvfdBoj*4hYtnfhmzEeB>_Ju@L`?t%n-cm?$c6PNAfW>>PgafOZ>W(xh!z@_Q63I` z#IwRE?Qj}ns3a*{nXJ14A+`KX^LwN4i0JAqvj-?+9*I6Ko$l< zQ1*q{e+W??L2!i%q;K_zAaY@kG!2TbB{g z=nL!@(i~8AMQt`KDs$I3hIpn|;zT;0^^gx~B+^7WaS&V{o;1Zo_E4D%c&v@2;%;4c z+|NDj-r0IJUy=hIlZNk*C+%clP_KS?od9F)L zd;~;pUTR_ozOjcQA}j~v=OeX2dHs}Mv9Th8ELL9;QDfc?4rodbar*=qq>Hdgj%-wE zl>_skAE538sU$KwQsdY*Hb=4a zpD&NjNV(1-Vls7i!9>bnba`^+MPca&u*Br9qP=&u`wNHBfKr{MbMPw_ME$yCR)OTt z#)lH$UO7+dqZ>nq^Z8S2RQPv#$UA=>;NA~tg86ruc=D-@C1vu59M zqUA{7tNF=}sa=x~6Jd4d)T(kY>uhkYndSTlFq7#UbUBP!lSC_rx5M!jk$9pyz)Mq6 zU;Kju0)4C1Sf1MB(MRJe+}iV}!v1(7!`(>hR4DFw*#pAs^mB64qm9w2J#(EDLktr+ z9s5qp$@-ioGd7RXePRp;kX=%KZ`~z@9I$y^QYyVY0R0GzCgtmiSoAL(TZpj02$09Y z9KKRw(VqWTv6IyKiuVa-Q$|aKS~aUGi|UOJw->F}HEKxuK6DI_8as2kw_Y@{ImWF& zToap20wHCmzHN;hTN+b_y3JMv$u(5hIA!D2nEO3 zcs?luZ2zV*Syv+eG>l?s+sMd1BB#g{^OU4+uX1yAR;WrDntIn)oSVbE5&^}^E8H#4 zEc=6zjaZD#YpR4GAJ1K5DV`Q!{1CblX@&6YK0{8jt}a-zsRJY}S$lmE6GLsion`Xc zFRv$rGHGSbGN}c`A5|iqytU<$U7w6s)JT@~2pWcHz;G}t!~5_Ed{TV$SkBk#-sQgY z)f9zWf@#v@=kgxadrNsi_gXH@oL?5)|4|Wg60|j0x8Ny`f zc)ur(RkQBQ%ef{a)GeR!x}TN57hdSwTz*Q`a6xa2#&A(I&kK??-53%syakGXzvL-h zP`Vc=P?fyC*%XCvpr3ngRAf$?YE+!QIgt?xCh->O9N6BZoCJQ_m z3453TJqwa?Y;ny&!r{?2xrT!G1bFRqXv z75U8S;{HZ8x$5>B*Nb*+a5S%JO^DcmBiuACbYBqH0tmIHXnTG0H z%nMx;sTW9((k^o^M-wHPYxqN+F4Q;|AIBC|z&w@U2!N+@^G%JQK_!<8`jWNlQbF@6 zPa)_~(40oWV04$4(1LmpiDp)`P9{2H*bk;G#K z#%zpa>~vm27=^czgk;1l0c8jEcTu=Hq@l=8Dq~46w4FrQD<;R%HDm&x`$_|$f@#}Z z82Me7lpPoDloWH@cCu9$n!(cx1xpx;(b^5M6{jzhj8xUQdO&XcXx$l_y_ot=6+o=e z@A$`9#KwuM6Xl|S)!enPR7N^2!s?B(@_A_BROyE|OKhKlxF~|s+JB-7HBh`y$N5Zw z9C?m5L~&%?nNEz#aOEv^2Ycg%h3JO7C()*+$K>Z*BBtmB5 zVH+@j2AUBfgA9X2Ga;q%_!%R5khY>cCn<37B4@eCG=Nek_S6F4Lmv?zX!&{Y(_%Rr zPbX^+fQT~fA~_&zfhg$ez>sHUC^S@Ri2nNm(NTp$$yDW_ePtBJ@u(rKAwEd+`cnkphF zI2h(C5bshR7*L+gb}X0p+`wOh@w4r7p5f4B#s{vr zSG5q!2LVeJ(w;i65aqPT;1$9%kkEakF}&y5P$-E)U!`bdh6lpSMvmOWeZ9z?v3uQ_ zjVmBOV!DJ-W=|Jv+fXh7w(|fqDX@)-izJfy)7-C4TMy$+@qiIf%c+up*=~e`l7ba! zTz)$!`63*)a9LjbT2=dHkR+Fl&==o{k}A3s_m2|JPtZ#2q9C{V6-pnJuwrdlt{l8Y zu9s39;5}J>^2XJmYwcO3WJguI#P&1ah$$Uu#%kQ2+xau#R zpw4{A!boB$dI~A=`QUk93?050uRBI_{qbZr+Z5aFP!I{&FnrKrPmSWGj!Y>Kf)m%BfP_jjBvAsJZOYcQag?3 zYCPFdasimD$9t}7x_Vgr05&Vl0g{s508dJ9aTM-7^H%WX=(FDL2~ys&nfGW2S_X@3k;YZeCS_%nJ>oM>1thIWc2jkPxB3?RSkBC+0SH z@L{9+o@(z`vnNceezhsUg@7yZq2A4=;PuxV8f3iMY*ydMAAbF)-T{t2lh^#}>ts1w z6kOFhdK>)pRl0ZpXum59mYqmMXD__+PpF z=-u@7+7z2szIQ$=9)@rK^}cVPzyV+!IR_;ti}lyZe~QhD+$3iEgTeX#8J~^b(8gy4 z*y`f;c{RtLF?}3I_J(>Gpv}kwHD(yR#Z#A)%@>fHifG<}CQu@OO+&Tk82`LpTt7@G zx##=v_4+f^N`_gvu`Eaz^z5)XkPgK1*Kh@B4;SMAdPb;%U&VjmQ$xy&M@Hw^5mh(6 zn=-q#aMI5wpOD+a2ch?^Uw#)pHH$oCp9znbkLmBg?3;(@0Ub2q5#Pt+0$~jMZIHT~ zvF7tb&6-zF>lrT7;K4&fHIUCp2;YI}_IiEfY|W?R?QSz)ei=>);l1AUE5@?x9z;_@ z15UxRu_1nfKj}^OG(_;(O`kT~`7>av{N!2elNjP2d@^%y_jLzwJ>QPOiyoBb!)HQ2 z+N@UErI2wVbcyP|(>tS+UQgh%tXsH8^aET?X5TjG+cL!J8e8WyfPJp|j$Di{7Nk_n zOGiQ{q>YfdnW-*M=d<%9oT|JdHsqUAtlq!*0`v5$v zd8|`$yI%iG0ZkG_O&kyTg3tbj^;13iEs^JHGXt*(9tya3@0^+Le7W6C;D6@2NzGir zxy%pWr5AymR=JPFt@YczD>Zi(;%xkNwU|KzjzSAB(ryePyO~g)<+Avu1Pd(u|3sg^ zS#MTT&BeT5cHBf0b-T3toL5AM0H|WB(rDOs}w{(_*jGsq* zy0=Up^X0=TP8}u6?Vl5onq_gd)Q5`MfKxIm89=YcmrIjBc^ykv3peH*sS>5TLXavs zCW}Owd){F5F_`KEbL_RHOI(#C7feh#MknwMZc6Llst+Os!(6w!(dV&GE&Ant-|W|6 zfV3yn^YL|a_;n=IyLnoI`yi$@8$SZhIq~|Mrg^}QuBf6!WcfkP;7 znha2ZO*a7*go8vOhqicsE>)U_r^pxPucHQ-sb!!eL-n)|3rwqIBx*FHv8zs06!c)kb<7jIA0J5{jx;-P*GXUu$nW9#Ns~ly zT-YGc*|FlmcV$f{W5xj}!L0~H5C8kX3=$nOC%fav4?w!~$XKf^dgPv~@m3cM47EYannN)$u2sh~4*mL#PT-b<=IERt1s zAK6CuU?lGdUb>Ete(fG7e~l>wLFEV_=|}W6QlWiK%7@#(`Lbj?2m4z5QltMLc>r;# z(a=fhU(Zm_-F;Sq#0F>63Cm}&8 zw>q{;sQ>ftZ#TjaBqTve}=_=0bWeo$i1osfj07nBn`W5M^J9P%1nX z;>4%2OLqNpdQ!j&C0RslLR5#6AS&|){&9!a4M|h@ZK|7$dIFV(7UEAtJ^tbLpt6F8 zBU}dMSS*&4dqnQ%55s?MH~pLOtFOiM&)+ti$@h`!JM?O`d@c~~gR`At#g}ZF!`M=8 zqfa9#-|Cd*Bb_eJ$|>`AXcj9JdZExB3mONDfTPxmJ{EMql~MeuudX&ZR4=8n$#E>G zEKEvDI!|#B#p_>+K*RW9vw9pCe<2ux$hYbZP#Fk7%%C#Ra9tT_pfrl!HRZE>*-RG7 zuQ*xmhWE^CFb1RUQcMp=r6a3>RxKWrw7 z0EIYdE{fdb=lxf$4{!?j=aoq8(BIF?r!6IqHN78{HWh}{U``e zAteQ<^jD6B;7 z1xq%1v<#$Xy|OM7}psj7e|-D7=ziAvixSfS23RakcPG}0eWkWM5P zm5W~m1B48gclW*W?F4aKV8`XqaNKWh$drDCkRuW)bczkJQFzyea|jH% zgJ=w&WJ&<~k-qr?`@H7F_0@Oldn4Skf0BBt1<}~!paEZTS(xe;9OuJCPCBC+$?Kl8 ztIklE$pj;65q$<;72X*2WF+*fY#4py>OfRWNeGBYYEw4eA@XT~J=!)l zM~YQBu*o2OATZYq?=(Ejv&gh8h#xZ{fOBvsiznpvJMktQ7mXqJ4s!$(mJd>klp|e7 z#N!Q3$Zf@&xi+Jsux~4NM9F{}&nH5tWt$|RnTA(KlN5I6_FAcky+dUM2JC4a zKJ;1i&v^bRlBCD$@4K(7r7C^N%~^JNuO=;A(?&2lk9GC9;_i8{b z=UTW;<2&bL50vu=C~`kOOxn@IFnQ(Q0Zbz>FWR7@35mQ4#Be5ZfJxP|kpLjHk;Tel zq7>&rs|x`o>{=?2SD5>VmmKEo2{r(NwZ_S(!KYpC%H_y!#*~sys+7uVvsB9Irs+TAij+vv`kAqDY!}lP= z-Ytq7pEgUaxG}T)KIkElMe#M}B)U2wOlA?5xq3L^dGT5;e{`5vOJ5Mqhxb$~!HR?X zz4k<3Pgjct`g)I1H23s~8m4Uy^w89}G~`N=DLmG^2zWdJhgFEB%|)YaEfRd{U;G&C9&Wa(GuAA*GeGG zjEpp1`cj$SC9IZGnct;k>s;m+CyjGeE{HzrbZx;}D{2Y*v5)jiAK`F_+B6c_I9We_ zN2<1MuIC}(>h)%*5t|j`r`^K`I+O)UnE$by^Uq%Mum17*4cvDkm}Bpj#>}kKcf1agaAtn0a}!ZggD|7 z)4>3d#A^DoWY28M0enIDXSt_Q=vRz6w&qB)T)EtfahqO=+r(K~cplT|J3^tm>TeJ( zeuGpsba{|hUGM0UOQ?q^r{9kif(*c7%HoVT8_W@fS*;rYxR3Y$OA`9;oPO`YrKC>j z6*B+q(W+-IQLwc8uE@pxPVcK$SA+>f(y&%r>|bggIQzbwJmOBf!c?fTVO6HL6%9(i zuUEK#dO#mYy)lF5yCJ+`{}76qvjg=2;Hw{SXpRgeW(FzVH_Rr|X4~a#*e}2t9M{ zu0QxbrQvuUx|2Hgpb{xWIQ!|duV9G+CHF(L;=TaODe(V&nJ+!=Afu@-eGy`*HYast z#_6KP1!yZsDj}y>pIQrO5ytoyk(lt1oAKGwAuERa0n%)!9B>U&UxW{J|Fie+d?H%Y z=~vO0(a9bsd4$wCKD)E&lXNPO1XM+)JhxgWIv@s2HmSVi2{9x|s%sKZGXXpe;G}Ld za%CuK0S7cfB!G5*Sh;JAM&c32(u6P#z+Dfri8JigH^O}%O^@22P$bz|_|kas6(-W> z5YoYR!m7g4gqYH@svs6FXio4xh>%FQwV^qNxu`^+foM}5qYnk34R~?_8*@$VfYyGW zYb{b)!oJ|`scz;0YRpDsn$+d(*#EADEI>(SI4&u5^HnKT@Nlw8S^-zE0=Q3(UtpZb z8aNc?rH?{z9hpL);e5GkBJ%>YHX0jMesofMqr0xXR87*@$ubnagu^LE-j{8*uZ=8mxJu7= zh(@G!c&h%9t0~nOk7aBSaj#Fvilaeb?HpzeYkmxt0y49MuI-tY0=%u5>fU&pW4 z-el?oRATUgB>^89RNpZA{=16YnO5+YH71tMMxzl2dasEk$>g>}D0I<|KxsGtAaZ2+ z-#Q1%?YAg_H9GJD?aBDBII9Hw0^9YQjn9opt?n`twTel_5n`kT$PJ+i9RxL$6%25Q z;4BVE2C^X%C>MM>(bQ-@855_G?@FCnzgj6+M%+G_(~%H2W2qBp1pKuwBN{H?nMB_!baGRvc#3*FW@nxqjKo*G zCp=V)JTzpUcZEh1bq|%8aUu+mxH7~zIpv)AuD7=mOGRuKU5EvWLzaww<=z7{X{bGe z7n6m|wIK^kH^g>DbcsgPVS+^CPS()tJ|Z#9?b$gH%ZVTCA+72^YqQJ5TGW|k_Z4G8 zke7gFNqT4C7K??HlfCQGuW=NT>z5z!MNe!6uWB#y!0R*h3E=*=_-k6MsSWwXx33ew zn`q?IdSxq3bqHzX)h#o`IeKH$rRgGq{3y{%=L`ANuKZa(63jAqQdJp@2y)KV zB9#WKKXaWLX=CErs)C02Qq3Xqks5HZeV2+dmFhT?f+cw(~T`i{V$w#X;pHcpB?{`1EPagKYS}^=&7#;X91q)Jy=(9Z;u(1ZbKW=E`V{ zk#=R0cqZGiDo{}ndZ(g3Z6M=(Qv4{$I?I5Ezy`NruvNZ2=g!lQ+m%G>dOQLJ00p^b zzbXO3HgGh>?Fk6sDD45Bs|b$=y4mxOQeG*m1>fP5`3e^qwWK}*>7*Yi|)bgXr3n!E`IhvQu7 zOY=J}jcyNWIGnZ0wS=KjLj|N$A_A`^xRXG1EJ;@> z+62iGD;!Pw$k*HqsiKa&7(*OaK2N*iB^vMqyhYgp6noy?1d15lJ8S z>Cm{zNFILr!z4rhA%kcyfH4D-^llshf86x;_i@HfVgpHrvo8GUn! zCfi91t+9Z&Vm=7$FFirDN^Qo6jFzg#9K&40n69_@#~HB#=Z!i5WN+U;BEPW)LUM`+ zAmT?7MnV<@ny$xOVw5)x{ru;4{h1qAVn_cEJEDK9CVdCk6Ln8e*naUnxhO-->`2%g zXxI|k9Pdf>8PX}mZE6l!oGZj*8W%Oo;C2`Okuf3Zwf$KinHms#0DLz)$7VSPf+iX> zh~@2aKr__d8hz9EGX}298of@JXb_^HY%cbu3stUb- zd0zBj4a(M*(uz#3AObtYJn+hCo5acjz8|yNz-sVhCM6p+q~t~Hl^SjRAsb*R$KXKb z5hxk;t9l}iF`6Sn0GY=em{&w(5Q^2qJ6=IUeM=(#cr!a*WOH_y2W=J*$euK7*LzKiNJcrH%B2IP!zRqNJ7vxfCcNu%PY|=o%?2)7VV*DEtqUprI>TwHfN^$bl ze)3gkQ&Fc)cE^{^YBt%8-^0^Y88mJFQnu7v`hO;E3fzY+a285*Du7wpjTAtIxo#W| zACLv;8}I1;O21{>ox*K$xBG((%UyXPjt_F3YShCM*ZGM5ZcfWOZ02 zD68GV?k}CjmMj1RZVm%4l%?->#z(U8uk8U;nSyZ*Mdw0lCG^kGd@_j?mBt;cHV6x< zFTb@}7alj}9DwfAFW%zS(&@PvJS2P3$NjZR10#smD=rPSbYr<`w#A85V$&LNfP`s%sAyLfbjipTgg_YC%JWM4h0~BDHgHi&A8=LrEN^TB zuc0n8sB!Ld8ZSPe=jhRRA^c0s(W9T#d-i!5B&DLv#XO9#m5R3~9s1|_^_0|1g01{J zYrzoUjr{p=3BWf%M3rAn=^q9|AQEzsP>LVveoIaA!~A7`^fTT!P7pubwD%F@RnKmT z4F5kmBK(Pk2|Vs$g2x~I!{L_`nZvPa#X4OL2cG3u^C8J66H0e6DH@9A2XRLN8c;P# zl1&-sX{YK z>*@o5SVOkR5>UYYk#edW2*^ELE)ra#leEi)=q}-M>2!N=$mlb8@$ETARpL$w)&%Me zRS;3sP+E!RyOH;WD+}6GG?0Fy-nQ8t!AGJ+35J4$XVopBOQ14+xN(8=5>~&3bE|yI zftZoz69p(tn9(f4B<}G2Wjq>O952VG3~waC=UDJ2Nr19@`lYt+Z4_PJ&edeQoqt&l z(YcEL4fIRj%VdI7XGAJ7b#uC2!?$UgX4u{vpYhV=^JMW~n#0F!Sc$NyOc;ONwS0d)nLX!xI1=E_|L9+Klwt#I|1(#sO{?&Gz0E1A&0|)KlcQ&i7OafRjfL;T^R+#RS^o%Vx6hfJHyjOuD9in4c^71%h_v8`J<&N*vu3 zuG{aZ<{IOAT+v@g8}IQCzF}z&P{l^C!5g=e$Aa@?`&5r!;u>?G7ob;eqzuzujl`;gAc_7;04|#VAbX=n_fx~md9P-F zzN_LrD?=*~_H2XuF-+rAH2}s+E*mw5-ZV)D&_LI>tGy>zkz>HPx?c(-sfpZ#IhjQJ zVDJt`s{N~l%m}9p`nnsTEZTjuHCJPGVhK8#&%o9!XTex+9^$Uqu})KH{S^ws+CI|T zub7Mdr({a4*R>ssN8jH=B^ZC2|ED0NgpEgQ=K$X>=ym7`kEE=V)?fyVGo#;cJ?;|e zt=D`|u>|lIWgTb{i`McgKoCOLyH;`n0%E;d%%}5W>t5$t@JD5c&^BFnRRbY4XhXMi zM(7_X90yYN#;IvJUIJA)e$^;#l&dU@&3uXj7@LgH7vLnG~|y1Pl3?C-EF>)d7L|R`vRuG_;EFR!h~wlI~I~KV`mcGR_|5~ zA^5sl%rJPGij+(T-z<#w&KMrHDrle`CZ}KVKX9dIW3_7j`SfmRhlD2(CXw-Wx0Tys zT!s9mX6o#^M_)*eOj+qn_aI5SqL7!o1>Y7L@#|_`}Z4t-3(L6qL_Z4 z&UiN8&~$gDkZ#dB+B;{)gI(k&rBPjK)bk$4LH`v^ee)jaZ0m_pIxw z9IG|oP#KEr6{*MEt}ON~fWe;&C=rmUP)(E8(g|v8wO*7WYgbB8rJ6xmL6!9jS5qb@ zJC&Hbe@@jDS^s52m0g??-A2&{|DERy2(M~AXb@ta&fQ`K^wO7FJN441-kE6vJlrvh zZv6J%reqm3PXBu6Y}$Bi%)OI_XyqA{Jt& z(mSI&H!e1t)#lZ(2bbOX<_W`Fz$p1=P;;i@+MTBIjWQLHr?AVZxw6}^lCCzOPd*tgv0;nQ8dyV4Ei%93*0mNO6Wmud!sQA-PMJ3S7D*q2 zjnBRcai$&aHJSOqourvQNXxLhE(2ZOFWxdc1@_8Kcx}}j^{rM4r;0#WL=E6mAX^9z zg!m6KRO~BlXu5aK2WX~qcv)HMg4pE;$k5Y-Z^UVbC(-NcMljPAuCoV+mt%lQYSo{qb^-;BqRb)T>ZW#i8~Xft%)HYg5ocNT*bb>jSbu2V{@T(x+)*CPtV(Q}5!b`3bhsyt#Pc zeADWi-uzq5N-FoEE50p>H1U)Ae^x)8@Yo;BLeCP%|?<}?FV4s)5`2o)<7RpLc(05 zs30Wy2nr-Y2eo!qtTFx*PFQwPl4p}5Zf;xx9#|CcLyor(^W_8?I;2zolYGTAZ2rq? zH5+eW`yg2Upq!jSG2QzFL~VNP$gG)>=8D>IReNpORO0dI~|I*9WRBmG4_C;A9y8kfn3&Mtd*T>_;fHdHoB zOua2(BA-)9*}&yZs%|OPZQ&@F!qbqIV5lUQgCJDuz*?J#T*bI0CpE|FcdK=|$ot0o z(}6P^VT_3TL#j$IZy;){y&zDwD4sMlP?${2Zq93#O3EI#l+%jtkT@nZBf$(> zFYgu?3mUEBQnvYwtn8&(m zR@-kYH5|L<+o_#MmH-$NHfQr4n6$MB_v!jmioLMu=oFW(^jt)xM$n7g!h3o+p<5(8 zoSwRs6A83VPZbYLs*T{jp<-n>vrnv*n<|%qg*^qIE?0Z0+_!S9)n%6XV?;n9g2Srx z1(^z@h^ookvBaP9ES1XSGh4w!`EWt5L}{6sPB+t}4^NIrRVzJh5^-y`#4m_BwrEee7 zn7f%T=SX8&FRmXZl+F2l_^{zf2zDP0$T z71O637qDDS7br#H(s2qR^AKeW`i6R>!oXC=^LmXO3mleA$uaNo=JDqFtaupy>%&Kz ze%T7&k-ebnw!aq~3UXnw6I9CBo#0d?=zk+`hyZ=?j|EN>9lOif$GjH3d@=4{piXC5 zd>e0f-;p+LqwTBBfI55dqBP_UsX-rUbovJ$CB2KsV)qqZ*U1bw5Bb83n?vBFM1q8q z-!%bRoIr?}Q^N1V(~YC3A4L%@4UDQ%q4Vu-Hn2mkDS7B&jbDEJbSIPqC&#h>PRP8) zRTP-$IaK^^P|+J-YD(w9j3si3 z4Y2`6H5=L%xAd=TjT`)TKY7`4w?Pu*3dDe{PpSi*Juf4PuP9AkaZh!8+&aJ%#o%aE zBEN@fzt%xfgiSTHUl0^Qd9dQZ<42u(C^+i=e~;Sd>&c_`k=Hw86$15c|0#YZG(Nw@ zcvRM3y1P4&zI1m+Zy+Dglm%5ytVBRb9REwy*!>s5tTD7;PL&8Ae0ayo4y4z)QO;2+ zwOC-3FG^&fz*_n83Ep?C<1rP(-EP*K6&H+?%$eUqTf~T-EY^CKVy#%g2wkd>x}Y1S z@^9gbJ0Eix8UJ%h|AjEt-zXauMPrwCC(80+KB`?@SZ_0-ZV9r2=l$b3R!3dxg!lJf zl6x%nmWK(FtE4!@2joqtIanDM?lry8!?-0jr)V8p= zh4EVNLr{^6l5rLPUivIAXotgRLcK7y@5m}R8+T*K!|4lO2^c&6!ghxV6*T~mN)&h@ z-a||TraS}%uY%v`f>b}CMiweH=^($s@YCP%nC`9tAhZYgqi%sQfzSDxXCz~s@DgUNP2tHnYUiE-e>C)?8UXtzh4cnhT;uaKb6R6QCOogV1buZM1M!@IoK_0IFYWgf0t`ASw}b2%8lVQ1Z! z5RrHRn*Gl8Z0?G`^=`P+1YOVZwm?-SwRq!}mEua?M};^e8kWec_)EM>4K_*iu&JSC zJU2k0-iP&fyNar-7-y@#ld2^|3Hcr!RFYA=+ljx^-f8XB2d;lwz@?7?yd#D15@$QB zV@B1onORh+=E_Pi&6%6A&f4YjnWtWA^!*KP>~8$q_VwxsZP3s*=)=?FJ<{1bbEh*Egx7~B6b_=mjVH0(4!}u}^(MYuV`8y|WSIZ@85=EIV>`v7tkc+s{{zIB> zWyJlUA-Ar!9|=Z>w4h`Edj{5x%QkAHBOM$8N9qmmk<$7fVhR)56QO6vYE1lS@}bSt3h z9hl5CMhZ;O(I>^Y)V~q&*8f%t{rTf$J)A2HlH#_YMyzupV3`F;zu{3g@8)nz@yQzF zcHd=u9|pJ=0MglP-12Z!4CnYfDd~#w(ODUY8BPl`H+KbGUNYhpd_|i=Hw>;^qZj`$ z5|boS_yYlI@CfjMufn#LjioA9Y_t{RJpz2F-wMe`+6wpo^0opl5OgmfC7<1JK3yV-($T1Q6NrJoQGQ`2$>EJ90c)n-PJnsZ+Do`!K(>L$@Sq=Z-orzFChbW)~ialeoB;1dp# z+nmD~etMUbmdHLU-GKO_!du+&%J#6kT{n5U-G0g(XYQ&x;m?%4m7}#TFG8mY`tn-o z@R$F8d*9a8HnOdIe$07Z0~v$iF`byTosfivoIXAFi-s{KXvf$r+mL4c`tyCWYL=>` zk}Ua3dL2fO4%kv%X3d)S%lHv_Q9hN~aKNO45hugZIK3T?ejs$}-AVds^kK^MAr0lf zMZeYlOQCz)w&(rCd;s+K0895~zWx->T}E6}ujSjEMTl%r<#M&6J`YR!slW0iPdJIrff_;xg@gTF?7&&%13~7F`4~j{rrdh zp#rj3-)pzFZ|EAcK#Cix=F=ho?Y&KUeS>2JCVMtFK-4>`j*sz>xF9l|#L7W!3iJ4W z)eg2D%#6;cgxg#d;Ui6y6Zk&f@hPAZ!}K2cnPa$PKPdj2E#`+wx%!dNCPK zzb_wr!>WY~+nsG;CYaCQA)Sp3-_x-pMzwNZsS>^vt&d_F3ySR6@#_?smbb|H3Oxm{jOwSQWe!aKN8sd{V<=&M4*ViTvB~k zwiP?W5+Dn~Q`8^cz=DA}!_g^FT7yQBIkXvEd1k(eI1msBuC2iU5;&8~ox;u#+H04L z%7?g8h|-xZ2G{S-ArGSzhF$F%u*e4nEC7ivY;)r+0RW8CJL1C8ZUR}b)#d}oz^NE; z440cf6qr2zi?a5vMO^f6qxU|FH?#>=By+o5ZkUUl%f}~d`SmX$V-3MWal)M7Igs|S ztzt$q5DWhy`0MNK|F8qp&3O3^cObUc)##}3!)C47b=ycjnhY*+#t9lAFQ4aAYnGSJ zd9Qs0Pb%um>6xQJB4k*V(F3o&C^e7_)E5Uyy|KN~Y=TBuOX_fv&a-H=JkVfc^jk1| zmW2;w6jU&fYO>ynOEaF9Ua5lz>zn5=aoX_4qoTvNgLHY+Wq)5c} ze%TXOJ#tHQQtKN`3;tf=+n_H0c;^FIX6r)bs_H^TV|7*?w@UK&sQST<3|aS} z(ym0Ryx7DetOGe|i)Eiyv+N_cGc?q%x2$*Cz*qQ+!4}g$vq+!jcL( zMJ`Ox+3^I0ni!DXwzDS`Y`Vf3^wax~th@9POcUn;{35sfiXf+}3m_CrC8JDL?35}q z{=@Yp4(Pc0ez6$DK5Mm@3b4x(amrW{BVMZv&VJFs%0;~iFlrdGHc%~QVVCPie8t}5 zvdg;VBPvQlRC^)bI!L85LN!Fa`Up~H=&f(ZlozPpkBL(c__6Yz+!D@AJ=Pe|ux!Xm zaV)BSWv>+j*2?oai>QPtnh?zA+1;24y{A@9tmK#;S=06fj(e^KDySBvhx+~mCQ!d* zknt?O#j`S{0#I%|NQFSkNzpt-I*Z7UjW`=ftT2J7j51v==3%Bkb7wTuAHN$RtTNL- zNI$@N7?x&H28rBXFxdxVnebof;=G#-QKeo0i z57=9jrEvy^dAjF{dIIg{2+k>=qiHU_uC_kMy&6xdbFi_Ez2#o(E-S!+K&%vtAxWcxC4LOGxQ0lX)7=e0m?zD)p|D;mFX^ef^> z#3mTci(i?4==fAY9SQWEHzIq73W3uHLUmxZHo&rL66z?qdPXV9!4NGC`$F{-3a>kHtqO|dOB6`_FC<}ZR|)l(xcN=6HEDODhWZO# z`*s+0z9}r%*F@XtPY2oBPBp@V>}Ur{A&6URtq|`tQ46g-ueC}=dbNhf^N*dbe6HrWGwA>?NuuEnE-v(#$q7O7U+=d zl3vh@N-yYzn&V+ytK8Gy>p0shv42>1>VFJ?nybQp&?@^M1D7TWwLqk-Jyj}T8QEpdyYkFzMsWiN!sA*A9X zLMjHk38_%?-TI`Hrj9pc2MBB%6$0@dOk<+JGo<4l;oZin`9*$bfY3hWM$KL{%E7u0 ztZfh>m73qcN-E@xH!dE90L)49TVHkswD-qJ!aFej7qcs4cHEM2{MM$<2dSCgQbheR zg$9LBY7ZELEK$2mj%dlTr<|I*wfy+*#y8$2fID-n0@Wja+%uz&C_*mcMPfngo}GO z=8e!_C@0>c)~2=^E}_v9yn?oB*4ph5{K}Sgtkb=89_TKze~*p1vZk`w)+$^36_Zzp zZC4Q6swFoh6(gjPpfCE}ZIU-%Um?83i%o>Q4LDHh?0Tg`%wT}0HYn= zRYp7b@jsQzdNaV>moRq-MA@-GcbF|T2@eqIv}C1PA=H`e>`bylE^i~*j>R|La^`SV zt$QQo!J^QqE`tIQ(63svrlbc5#bv!Mg6;s)p1n?QicII+V^fr*$cOVW5?@9AzADs8 zI*a)z9iqt*tN74rg`%Y~GqmZfY|1F5-^bJOJR2!qBEe*}{&9s$lgRBiCC;Yzv;Nh^ z)eD!+*u|Es?j%xqZ8Up&%`2=TY8Q)#RQ2K8=yCcp{gysuqlpO=>G$r&qY0YZ3_g*~ z_WR2Tr@#6{A?&JXsnd{+DxlfvA5nFo?ewhORh*tn3Si!$2K@Rsn?F6+{)y?sZ1%%c z1h!5<@qppDlJpw?FEqY3Qm5%^hCKrGPMo!S^Ui^ZFKobZ4Vg$B-83m`DZ%1yXkn;uYWUixl%Ska zUdbEH#Ze1>a3v?mLk;2*JJ>S{evO`<&Z z=J!&#?0_HS)1mFc_py$|6h#k-R)7q2*Zl{Gyj-L3B950D<`ukDIb@RK=jm*Y;z_tH zY?^uXNwJN%WIJ)tXc112!Er9U72Sv7;$c8`&cDva|9VDqv*k=bIZdUyvT3u4r=W53 z#eVh|njXMVQa&PYes90PeY|!4^t^bGrYLMoX#^IFWB7wBNtcWi<(%xsC7*Z=HY;`~ z(zQPsXqEh67*?DQKqP~r*c6Ze;LIVwTOC4xpSb3lXsA&bM?htVL81e4IP~FOI$$74 zzfXM7P9V?I>|f}R{9`N)RTg~lqj(}a$x}8SjelkfPbf*HzO#Dv0W2XpUv93_f$3o@ zXD7!(SYaN4l|xt5M}sree#$n9T#@P9hf?&Q6`&X@Dwq?vOimT)hl|wI#>E12kYhg> zRF@=Gb@37GFgX&?ef>8)MZht?)dZ$&(v;G!Iz47!DXc1vFFCR}f$qP8@v-y5FhpU2 zs!V-1M$O;n5p&(Xfd33`{4@wJ~_4KhGtuvTQ&l|7980c55hb0gdKz2d+$X^j2ke=Jm zZ2bX)Og0)X1|R=iNQrSrOZc}ab)LI?%^k2?hk@k5caWRPLe;0nLK!iPX=ck2aW%&) zz-|WxDE%3Pqm~2`Xwv9|_cR|b7PP4iv-yCPE~-@8e8I$oh#HQw!Z-O9De2!zOYxLv zQJ@NoPprj(e;I|j?}u+#8A?^2zm+)v#wcIpj);rU(Ft?dzH)_6+6k8Rc|I38o8a*B zBU&MoVKCY%Zl6a#z;7oozk=!JMOD6l?haUXpFfp6IS?Oyg`J$>Mxdn9mFx^4DA)tf z()SPJ(T{iY`SA6My)MS{_p>Pqb}wkGBq=W%1b_E!A*T+0+U$o@xDN+AI_VSKO-i@q zl>9M9AN-QbG}n*`MXs>|#QKE5G#9NlGkS(Nj}Ta6qi1>)LVzkk5N%MU#}DV(J-~Q1 zj_TBbHX`8O4^@S;0nXG4hbG6eEFA7=ZB_8om4)higcof}+qPq8@R^X_3vi(V<4jpK z+FacYG|<`=vkjN|6TEtlpm;ksc}XZD0D$sq=s?%h|XposhlEE(fmRo3ItvRa-s1AIN~r& zRdaf#Ag!x*kw0ombbo=zO1>4*oko1WquVBng%E$J#kz9#{&C6`dJm*MAzg(0o-0~T zEUNQW)%2mK>k7y9;yMc&Nv_$jAREpL=5>Y#=i{K-z_s0o5KD|xpxEmD#CK1ww5vH! zH8$sI;Bfl^GwC8Uwxe#$cGPt9v89GNkeiHzf-3AU?{REje$e9%HisZC3;TY|IIziT zG)2*}lSV^D+Ll{Ap_`_Qr%ASilzx8?2c|nM>XhC#4RWGb^5bJbz8X#6f$FjNIebcI z&&za_%}37@G^;c-8s)XP3`{4=yJrSSiqF(9Rgb?7n4D28lrBKb{MP7h-WY`HTCH1< zuN2`OMnSw*d54}|D~SOPaFE-575lc=E)HUnXbQphyhC;`=ko@SQZ+1yE`uxgQVbj$ zv}tFQCV@=g4E+qQgBfL$9Yn4}`!)G0idoWS7xX%hO}HJ7en{BT&usaSj{h2spO&yy zq~D*12u50tAsL2O-#bt6cVX`~(&!9S9rh|0-*ed|TkvRz*z$af$#A%scM`Tt48m(O z#`EOHlEpkZ(`SZ@MfP1v!%<2rnN!Hg?Hby!242bGbUH&T@o_pG|MU@|F%Qh92s_H| zI0O*Ng@G;nJ9lY22IO=VcLMOO@37{_wY8)kDo?CMH%>+nldTU;IZ``5eFmB{9A(Q_ z9|$eCKsu!nEUAgdLl`&oY=>xD8j$DEqs{L7906@|MQ{TK*5~ZA<#s?Ql3xYoX1Ccz z!WLpeJ6nngtr)+Uan?5a6orhT70}^Cz2(Zb%!Q^Y;i&$p<{ZUKf2)agP4aME%;38I z)wp3mK%AEE%@G20*BjQ%In*gXzJH#Mg!+y^LHbDYctOGaFJ5eAht%Y z`=}UU54c8?(-vDKtH~P^ag$^z5CYAw(t-l9zA8tssTG69L6;~D0Q>NNoSIDv_L*Lx zoN3PI`s8Q^A+(zRh{L%qo^%{){rjS$D@0+v`ew=LBzHO^l)|V1JOskp09VIMa za@Y8;v=@L`CAd;L$cj{;FbI94OeC`&DGc@kD_il7A7VkkT&~Bv)e@~6f%QSagnMkF zhb1)%77G|+L=rH6OCo|N8LV9f!Hn$paa?~WS(HB%dKean~rr1 zP1+Y`_jHzmL;hK=v_(*w)e{lu@`J)TD7IOLZ{wt!bCYy~PJy57b+lmJ4>Y(932gW5 zUDaAU_YGZI(2Qmf0fss@9rBrkO9KeJ;Ta0r0FtsTf8dAVYoMZcU0 z?|sBg1*WC_Lhi_1LsFCAKE#YchX7n)L$RQ#G@`73PUf8JERPZ8>=5vP8LKHGt*|(? zU%m4x!>(Gjh+GNJ)ipf3=Jm03s4l0}FN)qoAjftRna&LV*KmB1(rEQxV(hpZbOuCEQ}is_#Lz<;*&@d$PCFbb!|Dqib1># zI~9WvX|D?hgY`|STbZ^I$RGeCuF6C9{Y`y0_64l{&HEI%M;w+aQk5m%s*4qoY~cVm zM+!AB$Hei!>`mC=9D5SUAYmCL0V%J{T9r#uu`TE)bs!SrVB^9wk*IQr(bP-z!)2}V z+N*RId{{yBA`|CyB1d||O!ou3W6(iO`F()>*+MYS`^^w;Kw@oDstrgWWPSlv6X~F| z{}lj6Ixk6B_31$G0@;kE{F2v-%*>?ZT%{8yQPp+mLy=`p4qh2V_JO5@<}u2m@b@f+ zk7Iyh^fDjc!y81ightQO&txrS*XV_pqsM*@j2o4*6DFSZijNWT4%FEpF@Dp(n+JiqSyx^Q##`sgaTdw1MnXgZ>6((P;-VVdI+{u ze+0fTuPJY(e33{3t5dCoMs0QaSa#~3A)paR*6yI^wg0-0 zsJQG-$A1~azh1SC^dLuvgzJQIAJfTPHKlC&gm6+v?R+mOI&vE?DMUZH=K2&Q(_ywm zog6%ooZMxMc^#t$n5lQTvP4RXbsE=jhQ*)=ILZBmMtpo&#&hrV}))vxfC#jSc zvfWE&ZIVq$e9X4J8#7%46YS>nJ{~Y@qeIA zT{oq1PXDjPbp{dDT(@jmk3og&whK429~pn{N54FM!y6BfI@H$ z1JZ4Nl6zJc;SgrRGA_&&bZ9OZ6yrMIir`DmuLKX0LOcrR=cC$qvLmFqgExl?(Tn6@(pmeV%=PSVAFZT40;^ zNXjF0UXrr1 z!V5F8%_W8lj#Nl9CclOWllD(D^xC2ExRh*Wn-j|QN9q(t((PiKn-MaWIW5G_FignP zx5ak?6}bUSFTA~Owk)Z$tA5+Odyu~@@u3Qc{pj&MP0RD}r`7XlMfE8CGy|-UL^>5Q zJfb1-PuADrel>kBxphrRsMIg7M`1`B|&2He%B z(PwcWOZg9E=A+Jp)D2A84e6X^f5zzNcL%c-_ILBi?^^f9w*jzVD`+RsW-F&f;CBf8 zr}^v&?)29Ifs&lh$IIvW)P~=qeP}j%C2q2@C*Ud3&|wV|irNBT!OJSR*~&4+75rky zU#{2kHZ~-<@bTsb#cv9j4csPXqtweKP6=ICn%2T;va!^^r2ZWZuV{WlwGjX68_Em$ zvC`iDQRNTF1fIwlBIe)du(XbkD~J@W=7Xcx(lR$-X*ha{OzuW%#g8-Gc(l-1px)JT zp4~n#S)jLwHmJ*zEm;5q*Io*>oVfZy2xLKvM+UBVga3^|FV%^vArE^nsBiiVed$%r|^$J$isIE17_;+r%+Vt z+LtadUQD(``Khp;rK#IFr!dSwJ}8GMsI6%xiP^guDTT}d)3g2w|X6XZi&E`l?Yr>bM5B$^ed3H z8Vb;l@beW-v^?73`n6(tIb#2cvSCU2DXJdqN$p=wlydt5ir^8YZb+2yof0MOD`SX@ zXiA~x`GxHAldBH*d-Njqc&F3Z6Rx%8hH_d712|D&*%A;_G!K&7bdilraHliJz4Rf6 znL#w{Q?}GOVh4D}bE4(57qZe7soR z(e%Mm$KyNpxL00=s&7mDdHHxI`BSP&SPa28)r>{tUXMUn)ahsk?@9J!Te8nJ@RaLA zCC&uiyt|AwO^1`gpN2^%+}osx=(r%tu)!PfYQ&^{q<7&fqyy#YP@My`($m?=&OV8W zc(+@F0YEMHm$J1SpLK6Xv)lhcu0lF|%IJu8c#!=iGU2KDS`rsZ4D)O_qG~DW^&nI| z{S$}?c{Lj^lFs+>bUX*;g1PUp-yhz{9Cl1vE09ie^?Er2@?Okmk2j0#-^j6xvZPPA z4K)sLluI*PjlZm(AI$W+md!HU%G)#PFe|c=UcL+ z{BkBZv#ATwhW>_TxJ}M%4NDw3EJXoNg8n;Wb^l8XgV`y0(0>eI8rjSQBpw^EvQ$KY z7D^t~JzJ_RlEW5Ct11lacG@PEyEUv>4lvF^5&FTwsRQ#;uE?o_f~s%>3z!k1N>Wg= zTc{Z$TC8e(s#-2&+zJaAJciiXHQYfF_b4c%I29>iL)-O?U_}$y@3}+`KaI+iRVJ|A z!lR@&?gx3*ZeM}C@$xa@75>=xI8K7& z5M|dh{Z!ElwMN_HFeU;6-M76|YjZ6w)wZrgi6f^>=w%AfILBN;X#Cj#SZXB$uxvNX zg7v6kD&Hz+r)%vnDVd;lIaifIdncX%B}1hH+bz+pw!qt~x3(4D;N&ICzzukno8RFr zkW|xD^4QQAHdlt1a=^5BptzEFZDwn^9(k!}VzBE@ewlTb5N9W7+NHyWP*i)8UoXK? z^}W)cywIQn0SpWa7}l3s)uelujh2>k-g=AA&pUMFHX(!TPk|r50h*g%snSl405C>x!c+Ovo)UaKCj3?m_= zK?LTF*8&7(YF)|CBJ`af=Bt?7VaE*Mpf0rSxL}-(kv2iUJfn;4EG{ox4Ne6=tDW_6 z6Meo_HHRL+acd`HEZ7QYL6T*b8 z#roYs4A)n$U!EUtk=H7Jxk!xt?2yG@wBoZV_kzAYY#jpf6>4-+OldepV@}kzgTbG7 zjdhg2r5T=e&P~4S+$UdfiJaKYhCD83jRCiKEev|*hd@wN#l(eEEfLjR!fFX-D!#n# zjaTfAtl(5vz%@W)LcF<_Cnc_9x2PrK7q#2ZF|ipw zpY0I~o%(6o;()vhDseBhiK`ZA@LWxDDT_BF{#kw;CAaF#p6e4yKn}1R4)H>HBD0>* z))Zb40;7W3NmfB!(FL~a!v14z;`Q>{djYg3@I~vQ%Pe;NJ}H@nzi8#dT=vfIDpF{x z?`qlTRwUk|7x3?wTvAhpO0OZ;AMpV@Ll%I=7t53ER;lu0iloD03ws`7yvykh*oH|G za3&Fwyz`e?c4vxu_4_whhzt7t7mo|VJ`r8Bw!=!Trea)(*-dvJ8-&mx>;U11B2iqW z@Ffxfi?W}S*REx)Wa_&WPhqpkBZN$$uIe>yCAf7fd+MNxPCVpk;BP2U+->{p63jz+ z8kz@%SOZm~%H{IZo)9r|zF4uX z@axNWhg*+2AoqG~pfUc5Nm4~oY3EgKt2RPC$j{g*U~O75QNziLeuDyIsrxp9M6d>q z5~T`zJ*dc1O!HP!t@Iv2j$-&KEUrQ;#AzbJ+DCh%>Ro5oR@XyBC1XNh+4y7>Zlm?F zba!yH#rL2ivWl>I8scbhYNdxw<f9>Z z8=g#7sNZ0>R-y3Z z)C;{rPZj$BjFMXkGztZrgRGz;VC4;l0foSN(_ug%X5~xWs~cVyQM$*0K{rg!TQ>|y z&t@-k?KKRj48>xW=DA<(B}I(GG8+{OKTu&2xElDUW8CX7J`R@qp^jOZjeOz5Mn1qKQd z6l!;fGd6l;2-j#*#N$iz46xB;a9Ig!1Uw<`0{`KO?sSG0*Z2k5hI6{;xG$T}lsE4v zc~@3ukDXySDO*yJI2Oa7-e@+NNIsh_I~8_HEB`Gpa;5Bc^!g;lQt8Jb8MxIead=+M=#Ww>4U;f(;Oi(?+YuG#cKVyd?9s z8{HZ*A!*KsuLF;cXv*PZ7XcQ`mh_DS^^YT?Q`)__m0$KG*F3u;RndL(_DTqD(t$3B z%uQTE%_Ln@91xb~;nNb-T|~|dhB4;Ppt{2aY(a{b_awIh}1iLH|rwjw&S40Y-5sKPvTi;HT#8cUbCs&xf(-rm1K+_tPA}fjdkrYXd;WX)u2tf@Zm83pW`C>xa z*oYM3P72j<5{Mrnt2I?vQiU;71F5#9mA_yOH23tYO?zy!NiWhX+ws<_3PQa{;MZ?k z3H&M_OU^>x2)*1AlVKgFE8v_7(=v?2i3|{kzNarGNup>5DLs(%q+SprR#*u6m7RR_ z86)W=M+=CQ<2$zQ^+kVsMNiD@_v0m87|>kdx0ycV zD8Z=4#F*bXa;AohvHjAQzZfrSUup7mbOH>a6L4C8_{(E_ImvEEPfxHA%pReqz)>nQ z!Mig;&o*XqArPHijFa>-{ReFcSFioQM(N=3X*OT>S*pr>{*T1|3t8#EG4j*vZ8p7w z*XMC|_Y9q%rXY!#7*3uZhW{SVXL#=0A7AJX9R2mz@HTr%*hY1cA)Jo|uZ>zYy`ND) z{C1O**~r<;BZHge`S`EV_=)9>_>On(v3Klx;mYDV97@(a+GX$?jd5xEk3b$gcDubt z{V!U#?BFN%UmP>mQ!1oozwOz7&+NbF_TS`4e^KBj9sT53f5D=7F8@e$uH;ld(Qy+U zIMI*yREo#R;NIMz9ib&g}5gBTbd z?vWH@lj~VN_}k|Uv0+TVu*Yl;-aow6kN7j##UG;|(Ccrn%kev!3es;dUg|fxW#(T4 zPl`D9ht=!^bsfbqMZ{3N@+x1NwV-rrNYB;93uJInPF%a-0eLNc44e#c+skCIXBZPk zjI3C=?{PT_XvQp-$fzvGJyD>V_Di48a1hs1h@}EEM`v&b?G7z6JkQ73>Fjj zz14m%iuHP#kM%Nlv858ZM$ppBV->x&*t4Fsr#zW7oQN_8i-cH=Z)*d8eSDlvB|yjA z9z|$|l{R~FT~n1I$X(16au%QR6u;|52$x~C*QRQt&uhC%NV`f%yGpFPO02u&Ii8lK z7Ti;Ml(H#G>!JqWB4yKil)&^quq^)O73DJ@gK3qabP;D1jBTv{$w>y@2pPf%H{*H# zu@7GY)<2$CvCgCUFoW>Jn6AD{63iKBR}t{!2+R6_)MB4HpD1TJq0}J^wlf(|zb_w5 zJxKvFxNh*F#qkpb-HGrZN)NZgI}-!#2D_U*4#{sQ=jey0s9g?G5szv~Zk>Aej9R4V z%`u#QAM4YJ`70Qq%i`83IQg?M@D$}FA+kE|rYqGWJwalgNMB#=`*Jw;vp-m=)c;_B zUiN?aAACj=-ubJ1q9gb4GPzvhNTvR>kq zHAUtIzWzDOdk)dbgGcAxn*%TFgj-q=n>-O%{S3vAjdqh%m7^3^MK#1bd)7g4DTTc=FOh-OTF#o_-IruCsaO7s-)Atup2t?%| zrrRZ*=>pDl0cW~^GhM)$F5pZTaHb15(*>OC0?u`7=Q{Gaj(n~opCca3$6P%*i6KB{ z$8eISeis7g=C(OtH98bV74GjZ$z)&%^g11r$Z6==zkLM=H`uq8(dx8z7PKJOaD%M2Iq zLB&&c70D5}h~V-PsEct9Uk8%t7Mg{U9HlcgVUK4r!*%WoI@Pv8+-BT08!#^wh_4O9kd)SIc+>~>UiSx z@x&?QiPOjvQOP}e(3^=tg=L5*GxQ*rFerG;`)6A9MQ1$*e*62&qh!n?jW^Ui?e4&_ z!_Q-i9>2jD_SMu=_9$vXRm30N8Eh=U>Ld~hVWSfu;3F)8qDLqe=7yY*eSJciJSMtQ5z@LB~GqODA?8RKZyA9g*J)RaGAEY1ClPp ziHXUn+r%l^*S7&=f1#w`=Fe6tkUuY=tb|fRA_C;M!7Xs+voSLI_~L|!#7Pm!=_(vD z7jZiNnLfRu&)w9ZkVy`)Nv(yQ^r#qn*F~}M#8!g5dxh^4mess-6fp86eHg<5U_^O5=^Srvvy+SgZ%IG=;}g(V)Cr} zm;QxucHO*B@B4K4_QrpWN9e>QaW^(_6V4e*_>9~#o`pUdxZs1AYr6AM+5;R%{FJO` zZ_4G+`2R4Qz?9jSp{XeRp31KrMm^V|<2v_SbD5nkoL$73#qw36+aM=Wnw??DL26gP zqR`vYI{rVb*MfCim9jce86AWgmF%|>yuq!#VD|`LS5A6jRq&+D3_yK>(kc4bZ7{xEBGSn4sA1~7dwFumU- z$jJirzE2|fU!b$~Awipf^$^S55VFc~OBU^JEPyfSd?XQ!+c+5pWASjlruY2yBN!f7 zmBd&uWDC{$E>IDL(Om3Xx}Hf(&|c5y*W0u?WhIo({*s)LAh)|yw_BuBw>zd&dtd9C zx5-Lz$D79>F)R@7Qqm|~1PNTE34sP)78SdoN#QqK1YCvHB6k@FgZ6i9VdR*a}pKdlan9gF@i!S87iMrl&8T&?GAKE+Ym5NBK)y4qx#mC z(H>V_88J%&4%K!Y8Cd@Wir)arI07$b+2DDsP4$}C{wwd;ov$CrQ(>@e!vzix6WlLB z0pa>Bn42ojZR#6g7)o5^t&G@AsVh%sexh2>rc%|9C&2(8jsz zx#ynkp1VG8egCf?NBVqe!+kzq2L3YfSFn}OS6j0XA)jv-{EZvt^OcpI=AV64mmLGQ4jNS9rlaw169T0VcyP zE33Tps*5f?zwDw*=Us+E$?&R9QFwI+D+I=qVYsmQOF1$4D=V8Z?X+oS(@#3_RFxK2 zJ_?b^e@St&hkt~fg+I{kvN#t8hgSumm4AR|Su9av{gCF!e?hk-z9!;V^&9QyY|B^1 zz3@DsB*=c&L6Eecp4?W2<14gjNpZKIuFRB`oquk{x$*jg!JF?E0X(;^o8B4eUs+kv%o9)W&zPywh7>Cp7a=JB661v9g>^V2l5)p- zv-b4)CffL{JxBVgKyb<>X*RoHq;D81cAhxWm$$3WHyUZP@W+2H%-s>D`u&56gZ!%s zjP%{n5hPSL2b_{t^E)I4`+SxA1RNGCZp~ai zA|u$BckR)M36rirIN+qeHxYoH0@Ot9;;ukAe^)fs=re2Zx>=yz-$_P9#^OyMQ-uE@ z|Dvyu5gzm76{r|4?FfXrC;Zj);{73n4BummBE7o9{0i^;1RNsU+3x>>j{-&B!G91p zp^|SL|2NO`(Vs~jmB#>mV~UnZUm6j?U-~hES6(2Ty%q2=c>o5u79R`G?29_l>gNf2 zQb%TO9l;ZpPhl+uoQ;REe>q4-Y-GSG%cLsv1W}j8MQqmrgG$3?gGdtIAo=3vG%)J%?QJ>}S z!Zpo;cKR65PU+QaR!kLQv;tsjAXwn57%L%AlaZa=2;!mIs{a1|$WeG?2~93Fcd=%; zr4Whc61$za{Di9;%vo-!29ulX z^DRxQ92T9Awi{4(j+AZTj|plyh*}_&7CjLJY7CXU9=R9%b;Gssu;7!2RwMJ{iIKD7 zVH9XEnJn;gCNh?$NGdHLFQ5wgPFfu1Mj*or+j~jMaQd-82soA#$8ZyWOy)7{ab#s0 z3Rt36?)nm+e=^Ig93ae0>4ggwD)&-3>X>?}Lue&v80uawDZiDJZc_`$DBc_h<(Rci zLf4SL#`J2?DTZE+3WOHUX3Nmaie05J(07`dX5Ns3%*hIbrv{?wJ~K=hmpMAIBs9Fn zJZi!EYbeXW)`FkocFcj!R4<{^{Y;F|7FxPDQ zb_9zpHru}?R03!ZQCry0Q0;srDu2u}kt*}_4C!?YmqK>y#GfZ71{6WSWX~Bhn~qB? zG7E{(eXYnuvur?6o8zK()te|Y!DSC%sRE$T5_8~IX~17)|F`+*0u^GXl#oN{;cOGL)3LZ2YwG~+8Kh~;qdePTYdf1L+{ApJcl;_nER zJj3WCh(;$uYFBQA)E1GXP9??=$WkU=m_wwqD74X>T9EE53iZM=2F{vx&a^V2VTU>8 z>2%+`LtJY(Z!yQaz``}HG-V+U0)G4NaRy zCZcYg`P^m@6?V5?frnYn>~x~m8dHiuAQWE8TJ5!s_+d+Eqg>jkmkf*v7q}H(KS?Sy zYlYT$g{fLWGEm`fC`Y`;OgUL9bZCXnc!eFbf@Gk=#8YgAyHAx0U0R_hUSa(YBw4*= zpu(R}PFfgMA{C5Q=#5uctra8#6)txx^xGQRMWS~MX%CUv~5Yt2L z%R~Z?|AlRL@6!cLhRAwtRvgS+1tS>%vkS__SY)n&@LN`!%Ongp*0JurZrx_B%S6;|Fe7YTZMTzkm!j_3 zT6YQSp6k}_)w)bX-KD0(X4FbXXvV%7fpD!f5E`*B=?;xClr*7gm~<)%*RtnD;V?U4 zZnP{N^Rdc6j>CHv2nk^wC_D_&AkQ1X)tY{`-frQ~caNr#ApBlnqtl6PEcOOBo|CCjxW zM^IZ*Qc&`rS82%>QqMd_-MS`Cx5X1;`Bhe!SzKo+i| zQH9wJ`FlepKSam5fgNlB&4}@uq#$U|%)ttx!^}V+atr%pt6%E|E_4H@xPhr|AXO96 zt9NN3Y_C>pSbDWw!_up#G%US(P{Y!zyCsZXO{fA8r@Gf{`*^y~9YJLL2vzq%+xtpa z+VLc~CKrQ=!MNOuaT$5=#=9Sb_MtXxL7(~gD1ZvC$}L?f^@D5RcMwK(pW#EN$jT~R znYq^tyrF8AqBV29G>Q0t@}m>W56CAxSSx`@!FUuB5FY?#{8Mit4=D7A`w*Pst2oZI zKB7~)sZhhNk1&{qD_c3RLfOES?xN5J!-tV+39DPpVstOMJs4p^B_B!3bxheY;7l=9 z@J0e5xB#p2Fcix`Y|N{Vl8D~^fL4{Hfs*JQOzITtIJUOD;#&xOJ5Z&k$f@iIIO)e9 z=uWzN%$000oIe$41Jyw2Wy~#~5C)`=m0|_vcZkk(;OZ1+1cFsLzKUspv6TnLVSq8y z**4(J%)nm`z^(b%1FlTL{cSv3EilI;`V!qNvko1DN7LqCn+9I@z;XDB^}=xAsCuMV zWg{J#;V2mOp&S6@pML=1WPiKA`aGXA?{JW_6XX=HlmP*B=l;^P=?xkED zn3d;KXF-%9^`+A3)#$6tdbcJvzeoR+&rc~KGk{kdg3GV0nEe<98Ay$f$G*T0zTYO z_OdmNw(U?w3AQs~y(1?7lt+P=l3z-nRQ5EvKgn^gygM9d#i-DR55)Hp{}5;&(ZNK=|3k1fE#&_p+Ji0tR9qkj=*Je&llEX- ztiPcWssj29WDY@N)Pf`U%b|CwCU7O~SO$Zu#w8Fy=?(sf2)N^Aig?m^P5FfO$@tS} z-XjkOk+)R+@$x@aep357ev#yzXcG3RlpZQZ3UC>ny1S8Er9&nQ#8A z_Ev_`f&BCM8!>)ce7yV~oZidnQUirH{*vC0+l1^?#LnES&^vw)u0Q`JeZ2Y_2)1XK zhs5Hyo0rrCrqJ)a7%|)Z2Dox+-fMq*>~9}`P5mE9LNPpt_lup~3xna-?;|ywzpea? z*$zL;wufOiyMW;0;i&$Fp+LtHKp5IWg=E51fykj1tKZgpxrAvt&ffMm#@U?-tf7xo zr7BOYX5ubPbdYF#UZgx|E$9-ou9BZI&*S47%XVd@8}8S^4FUu~F>f@)P@)v|nLi{a z{Ei7^=uw~n0zH%u^Sq{N?bKpyjb z-nub)b=R*7P_PTq-?d@-gtUsID0uf0y>R}X(qVcBbl%L|KLHcu9?HQG9uCIso>0l( zz=dYBGxDNmG53#FN)EtCJ2TYAx)h$9Z1VP!+^)%4W`RxKgkQL|MWG+rQuTf5zBXWk zeiy`-je5*(U{D-?S$&%o$38Eu@(Q@eO93Yk`o!>iFzCeYZwXi6G_NzS;42G|BS8tS zWM!)v4zEijtJR!F?sM7j1O(cq=cUPdBzm|;JU<4I-D(bU%Z)_$bV{u#W>~rg2jGNsp>WFgR%+!J5?5fR@y_Y_LTZFL}&#pS|5{0Z^5)l*(YJ1)iI+;Q!v>che{T;Z1`-KGvPyG>jH2sroh zr_KK*#ni0fv?$zCg(TC%u$A&}5Qa5NkL*L?vx$4LKK!D4?-gE!TXc1x&3uW{WS+b2 z(r8AgfQHjAdYx>p<-#6>uF>41faj3fEj36ryV#KNo&H%GxP=R`=2IXhNRfG<8xx7fB#TC| zqG47m8m9;v+;#v+r(_AhbP>!=k{$>*F-8J^2e@wLC`&3}bS%mV2MIsAw*(JCF!HUM zr#9OT=@rHQ24V7OS_VcGfRAPN_`Odm{{5T0wvAe5RoFsx%bZ8@YR z4M4FM>ZV*dz1|?g-tQHdaw6Gl_+=(~h#~AK2k>)3h8lwDS&|+6H;_#xiETeMKEM(4_t&sX z$gX(jukQGby?J*%0e$&t`p%8P89)y^KZ^6$@x$fulP{o2x9Q8HI?$^~oP5T{bM+5( zcNPklKe3I{UE09PCtw24->1K&nhJ~BOwnCxPoSqS?8`xk`f`MGHg;lU-nBVi#ZVLqYr$He}9TR$kiRvyVe@Qos=d@H0x3g1K#lkw>- ztgGbE(wn)wvfn&CIQ-c9Gh1jz3s65SLwnZ8X;Yp;YcN-E#b5v)kbw?9{Od6s3e{;B z_UejxBlD=pkKaLGxdu_0Uwh=SldZ{GDMTns#z(Y{@V+umBrR@2a6V!tHnqe>?l#y& zwj`kFN@Im+EY9))>o?a(jdl~{?*Iq(e>4C0t`8gsbhMo~e}2jyOyRheWDmUXKE!fL zQvRvf@b8jtxeG9yN7K&$ZE&UrhuW5boIY7^Selkudk12=xSvhzxVXO&i~DX3bxdwh z7XXe90JK71d(3^-E2ysH`i^O}(fsjZ55x_Cvsh;yf=>fc31?5zjM*{_sz>me3!}mC zgMTb0hfM-@uaBFjTwRd*8Crjw)-U8Z>Dc;Bk_cfKFNH;hoc!u6nY?|CuWM3JetA1a z?-n7AAHvfcsf&lBSAsZ9jGpfXPI3d2-M~0Ez)e0D2DWV2%)bqUv&Ur4moV(vS(?c1 znv*mvUeI(cP-iA88|SV76|2;`cn?Yf$~(h z)_j&$SF!=46xf8?z!I$LG|zwqaA-%7E|GiKYb^1YJ->i(IZ#S$5;-+Xnfx>S2UBlM zPj>?VjtgKvHlRSgto?kxebegv8>6L|8+4&p@aq7j>vKZEtOiRpix*RXuz3-z?(tQQ zHecU@DL>kbjt7(;br+yFE0vbY2VE3fmJ%m8*X6{Ddsqo4fRA7QH_e*GcQEBQIV{lM&XGn)Fdk}-c zRT-d5%zpf2dyj5lJMCt@{0jbk40_s2IbJ?ZVb}tDctWgP44;JY)UMAaji*^IFU*0T z2{MD`Z?6865HQ6v*1n|&2p;p-bb#E8xH{>%plKl33LJ)8GQ>r|)hAg`O0GYZZ8_<^ z+ia#j_(yLU41{>EmPtpq`I90_&c&OH@tfuOm;S;?TC5zLtL>i!425BDIMPQ}mGKL5 zjBU_Zf0dS8kAxbFALsA&`iG>)I2EZ*bV6o4;C{>oOye;@Xc~c1Og)o_C-w!A#`KsqO4(BG-+9~M;_rtd%Y9@r51_ToE*m4$e5dH3YY5;#`iY#HTOvOkp+=X&I{ z((>V~D5NyLTNJ+n$t-ZvMU)`&;(b8C2l+vI_ zi7~gK6x|v^Ls$G=I3FRM<=(o#H*ziA84@G73cdHv&#e7~cIpOXkK2${+$i?NpbkJX zb9sTeS~`UhKhzC_H9iEhLp`Q1HE=@h&M$I7Um$IL1?k5qyF<;Der_aC^-Fq9cU`&< zJJZ;r2DqfzubnR!)>UH*-ro-%4wSzX`mM4VKi|dv<|H7b`_;V$AIOFgC6*YMUN$nG zsw3g0S28@SXsE?uSkH^a?5D-YYd;5TKek`akzgWG39if_j}4Bvg32;ho+atxnYrr~ z$@sYN6(M&$=dZ$lfN`CIxV=fTAOEBJp7}fdOW+;sOS=wEzd9>daP5-3?={a6HSM14 zZ^q~N1NnP`_=@dj_?HxCYZl`Uhx#`Q*KouUm*CzU0Zzk#f#q>TfJNpl@hRc38!5q< z5^ms>5XBIqZNjADvTtOtb*BhnSjC$)DO_D6(}BlrG{3DGP;|W-I$LAzi0U|<{iEka zGEbow8$fjT9NcZlh?a0J1qtba&(dgK`kI|a;OD~4cC#(0Y6WEn2AMY*E2S~NE`wcO z6(mQyFtel-z^Mc?jmbf3=4jWy1gqocJ(J{L{ee8Fa|culqEJfrt;2Nw9Zlk_U>&i6 zFi=g;CK^2Kfp#01jxEs2nR+*3DO$up%f+MzkQF6&z93ti?9zT+!hQio1fZrqSLyC)UU{~V$tNsE84(QV53)y)(%lI2)ej|2D*NkNV(*poC zz|pnWS!z=-|Ag;ll`OeEG=cmS_SSPA&Pjii9k!DZs5p1@bI=ayH5=UkiZWwJu&*Bf zCl!3yTZePnn2* zu-W{U1Y~{L?+_~-p!$UT2DdNeFarZpcCK5N{y-GK+fCLx)CH*8NCZ6VpK*RcUc`P6 z?(Z6&=TIi5mbXVYlmFB52oj7Jf^3+ckybIvTwV=z6Z(i4vKPl=po|kZNq(H+PF({4 z;4E!O0_GaT0#k-pY=e!t{ct(S`bWcq%`E4uX8LhVKaT|+H@)&GVo=H4GUjrA%Cpw* z0-+7lN2OJyo3{}(+q99Ua_J9SQ=cKJ4Y$H#5-a*@4!kbiH*mcKj3~dB(mn9JNX}zO z59jYCKV$aB&$10zRy6+vAosio!?GJC?vTlpELgCsd7H+`9=(a#-R3(f7CSHUI-|5h z4+GWY^(;A4R3J-P&a5occ@0}rW|Q)ro&Eh{pJVzB8-;T{!8VB3_krNc*tbR%S2}7y zGU+64O{GoON8IyQ5L~9>lo#p%{=#Tx=&-IE0*3IJJT>EJ4 zov!@e%?$)vufHGwgee2TO}rQjDj!TJ_)RB%EcBR`?ldcP-@)29IqpQuC;61$2>2A2 z-`o%;m)N)ZZG`+FJp83`V1k(o@(G*3 z)>c87_PfZ*MYzk{$FNMvi$b57zaYjP$OX`jZu1UfGr*b-oU9WbF+d)TqI~n{#hw!2 z21#`*7b?t=NQfR{>zL7u`J!W>U)bBS6MU)o@vi{^3VP@pur~sZP&6jpVKTzH~Uqac0^T6(S2d7IG6gWIJ5S#A~PQU-7`6dPbVp2dSW0xs0XrmJRvm}1U=|hGJ zZ2(8-n~+VMAK<#}^o$e)QGYWDo|PZh9t=3o?Y0L-+64ujzyCiwfA)-bW)p_5Bz^Jt z(@^x)lw|xKb`>Q~z312o6Y&RSe3(UZ#Wl;K(0U95IjoXN*wEws@mu5+FzE+7oj#md zPQkSP_i$-E*p@@X(PQ)a_{)~;J#0Yu*{k&MtUkN^P=$8+zYc;de)gVj^SKsYf&HC@ zU%jSoCBtLifiInA*mCi|b96lf8(^Gt9cM)}*q)>J?a-0AOtbm85lMt8x5@s5IYIR+ z#eR${Z#w?0R~V_rp9K5%Labbj9try0?(aj3G{C)qODg-uEz3acr^gFhU-1c*fDD|y zU`))^wm8Zp=%Xt?qJHqPlh=#ge9qT4RfyOm^gp%!^@)9Eon&}P_L%lL!9H=e6;7YF z0WIlF6zFpY7Go%H<6&~kC16zP;ex4qa)d@k?SU8H6H?MQOWQ=dK};xjj+JreTgmwR zblltCB{5iDekQheWUP#~=dGV&{*i({TaHimf>ivnvPxfd%o+b?3Gu0f#Gyd)dHyZH zPedv{KF9i-YW|&IkHCN&bIKKDH7Ckh=B5wDJ_%#4)3CXczsa^LMqlxdO1NWzcWtPi zAso1Xhg9VJs;(%s*5qIb0>6Zati>h+@#4^0JbIBu-}Ac>jINmpg)a(yWo~-Ezkgbr zKhKB%Okh2eBU6Bt7K9mvs4UA6VwU-SrQmD#n)bbnP7rII2RJ-DvXso06Co|L;MAL~ zU(uDl{G)g@9%mlu>4)nj?+>_nL>D`Ig68E)UK5L$m$5OzycQ;!eKFUuS0U)9MYcvK ztRp5jt;LJuAq)oGO40eT7EQN?rP+57j&#td1Ml(d4_2v$Da1xB<~RB>YsInAZY&`J z(?JEIlV6GB^k{%b!_f`Ndk<>@(v2mWr>_e%$?5S;-L@M{G^KAPbR#9|QZP@^6%hMs zSenWq>SJW^sccjZ<(Qp8dSycC%N|~3m=h7joK(wYnPU*eKxGd}R{qLm-To}b!-U>m z_YmJ=5J!4_{U4;)a!@~9FL|G0c};r#h2}L1MdU2MNq2kAM04SroA0$0oD69KZP|)B zM8ne5J_tv6>VXXV^$KO!$uca$Jr7nlC!#JVaBf4V1oc(-3eYU^XzL|!KNt1W6!ktu zokh&?pJ=@nCYs0K!h7T{CBvlP^_Rw4F$**-Ob} z36jC%Q~ILL$LO2Tv|o^}UJ?j56%wmwuq(<8Ew;ThkiUyyk5%M0(IX2Tqxuqa$KSMk zz6;3wNp+1cn6bd^R`ujm7HXRFgh>$a)9#U;%vO5MXX_iVK*iPtA7+@tEqu9RVQzpZ z0XHdorG(MK<*&1n++MOuDLwfG#g6Y+iOP<110LO#1`hRr9P5JIm36nrLN(1E=Uk=g zV$qKM_)DEyPv!!h1G6^)0m{n(n$Tf>juHd>o6+Pz()yYmpJfn!9_FkDf4;!jIx%g$ z56+WV7?KL%b@_X-&ZjYq*qVZPuV+4#J<5o`buD z7fX?QrAUFfup9!#Z6(>>=3>%bkacq+56|lMLXWxJmOYMTDVlor`%FkCCa6p3k-y0m zR!aM)7xO6D+O)_6Kv-Iu=pr-bfX`8XQXr#(cSd^5u5LyZ_?f>AGR^ZB$px*73#Gt! zFA|9Y^W24kV;6A5Q%}V45h$&BM0PkZ!6vXbY}s2`7P~JN$7cmE8t{!~yyDnsrdk}i zM7|bFY&mdO69t ziw=O?$VDFFze4{3gEB+?iLcM(LKHdxr4y$hu&VZz`A@4HD;yR*h%v5@i|6o_`LhJu znM#d9$K{~J%jQEeMBcFa%J97ibPDU~6mO1OUzvLtbZ`X{+&BUL435@2CqO&{&^na- z!L7pA6WjdVpmHS^Cfdz()oUDqu`4ri{Ys!;G==_q>9?D-j~hKg!-4**gC5JiY7Z7( zc}(BC{1#iUBcTik1@b1X-%PQ1CfW;@M_JGM-b!|Kzz%=XdTwmJMdpINffb*pnKLn@ z)a9Tmr*{MKpTf};x7%gCO50FlvN%Ni5^WXD0 z27__jZ=%qh!g%tMkm8>_pBlJ6CN?&(;!B?%Y<^cSUtl6Q(EhWzME!8>8~W(d3;ZDO zIB(-$Wv}`Cb3u=D%h+myJ0FYF3wU4>m$YB#_Mdv!19^?<-CpDcx_A5N6FiSe?@{fnLd;)w+q z5M5N1^IqJ|`feY*5a?dv#|w#(PtdAtjzJmm9L@lGZ3f<}XADb#x68+yf#=${7;2b3 zgBU=SL+9!@P@T8Zc@!yx`_Z46b|wjiG;ss)bLAmewT-VbJ@fR|==SR~vkJ4;XO0hS zvp(~j73(w4Y+Z*xt6#2tT)2k!CIcaR4VACp)X%}dT;x0;&XuDtdp_JwgkaXV>ZeaX zhQj427jWc0U%=6m@wcKJtm(|qdtiKHz}_`G@K7{?;}u1rFU?5^&vftxScq@1VX2(E z@E5ZHZwT^bGr3z?46hQa<)IJErN|S%t`1_@YPuzgCl(uuLVU`#vH^rzio$Ri!&SsQ z?5`;b7uT75;35@U&1$%L($F+s6B5iy;OKs3PDWhHG@D=Ga#T^M2aX#l5;Msh;ju9y z8>I{oEpxRC@885G%a$P$CKF)5!%lPUc?tJ{pcm^ix5Ei2_+3t5o8XGH5E+x@|6zUR zZ1QQlLfEv}`1xP*=ew3I0YTV#_szH>fw^{9it-8*g{z4b!F3(*n+Jnd8#;2m4XC z_=|a&YdbOzC~hng1%S7|!TcLd17zknKfJ3S4Nvh2A!^LW$ca|O<*CNJ#+1v@(Dt^W zL)?Z=KtqBZam7`qYPgdE{x${AydJ{e-G#rzR1+GHqF7O0VlH7yrrj?ucb9`Hz%P_> zw`_)vum7by{`!e6lgD#WZlFAF!hSy3S3`TT*MTYIaWWDIlgFcx=aI)JCAuZ@m=0X5 zJl@@5hf86;um!#}9 zNes&|eR0QQxZR1P_5VM8dicIA=;zX>TFF zfQ#kV@mOCKeyu=lFTdUvXu_{|LHaG_*Y}+K3IAC?fnUEBi2%QTIMd57weEAkmL+fo z8{nd1DY_EQ1~=;c@E=MSt3PO-*iVRsxiRl!!2h^_q?clJR^T>lFgKx$bgc)akXq7g zu0k;+!5_iQcq=3UKryVce=R4_Ao`FXP_xaf!2GAJRBiz!@ zF~A-Fec7*=_9vegb_%!oU&veJ>@AbGw^44OyiNI;kg$gKyA0t0@^&=~3?gsWAbcWBmkq+e;)G@^%HlGToH~e1KaWI|YwxOL??fd+2JFOZh4_+aV^$_uH05bJ_ z=%W9CPVRijob{Xn)~S%pFX}$VZfGoOabOGF?*@-b)}{Ua5444%@*t?uFD)>xXrrE+0!%D zWoC`}H;9bLiglUiOwYhO&k~!SwGJK-=;H5jsj#zkn_`{s?D+-_Rd8w(Ci2aTM1lm6Lato5>jKdVb z=`>GjDb6f0$(0|1Ujp#rG_#CzDM<7J*^Xf)QqR>g9_{+(s^PwM(=xMuo)fTpBEzcC zez;{8fSEQT7{8i^kpy7RJqL-CRxUWz*1+)6Wwt>rif4_jio_ao`l%KH?zqd^n7=3b zoPEuSc)0Bxee5t_Bn>zTD!ByI9KXJYwR*N2DV26JgU^woR6QOq;r$)vZYn`8^|#H` zoWy3~)j)X)sXS1QEPpd~vjm)4mw7g{?Tok4N=cp8*WOl<7MWT6D@JMRTUK!$6br@A z#Nxzu{#65-T@-J2l&4w$Do&Q6M7*6O7okjKBH3dJTRaWe676SLf8i<$iC8j8ypM_e za>GZbcM9;I*fHYo3q_&r#jlHJcxim9ve7NTQ!f(rUlMRMzChx&J`o<-H)PPfN#Pd$m=yvc zF@3*O42wcIr4}WEUU!$U4?T%Bvi=pRER2!JWbM^CdNz}K#8%& zA@9n?0jHi!pu@d%V}HNcOo)cRW?tqYA{STgDN$EU9RG{*wn!~&QOhaw+Mz1!+)IaE znk<1O=E3sezR2JIgMvJKQAzu=SS*7qJytfF2T&kXYh;`FU?r zs*ea9@TPoG=AM%fUAT%;A6t6SE$XQ!a`mN#((T>PN?flErw_j!00#9p{`4J?-vaw| z6Uq&=PZhg}D2aVqg75(Q^fU_$VxOKvo|q8G50-7mVasI8rj3UH7pd54c6d(2yu;jt z+Ftu~w?G4bn$3N?Z@GP1`K*OEne`Lw(`{-IGX6pP`Q+$6NMYY}%{(ku1I-(|*~D3t=)EkCP;E*j zULE+)AC!_UOW6dDHJfW(Fl;6ezE?6}Uv6iESgL$M8pibJ6r3&xm1rjjOgEYyxA36s zPYEEZ1COw5x@t|f7gNZ1DyXa6Z@ zGyu9kKA3-aYnVJ9Y`%BOlf)WB#b&n6 zCZpUy`}+;f-+*&se{*(BVSgtgaWMOPB=X1udFQItES2b%_=lf7q2>sK{_TIEFYI~JF0goJ z=ykY>c+L-o_#?is<&X`XMWLn)TB1->p%t_Mey7#+q|KsQO&q>O_>3sLx>Oa9GpV(%X9l z&sQ-^J+I>$nXgZkPC;^$K|-f?2bz%?TcKTV zPIQ-qsM}8Wlks-mK{zrR729i111xBz&ymoyDgF_eVf~J0_9wqZ*TdL}RfqLNFciQF zr14M8eLGrlXf&tcl5ducg8?vOM7lvTQq2DWVW9Z=$P#EW2OK(_-tm7 zz`V4IG+;Y4Aq8)`dJ9NDcJ*MsEy9tDQL9}hUL=ui9&P!E`$3Au`~)l*GfxT9Tz7GV zzQS%|9=THsSFx1ThuSfmOIYDr>56sE9UT|;(^kfzHppXGc)BJnR#=h~Zeq-wfgG7< z%muE@Fjr~WUY2#_!D8e{^VP^9Wi>I_HUb%01aiJ)keLeN&y3%hK&{9mnR4nk3z-kx zSr>(52JGmG-$$4e(jm_#wQJH677n-Mu~*?H#>~ga5!~n746_L-becw>6xK)WZ`PRm zr^|Zk3bT&{wySMWXyfFki80fSy1MWsjhI8R+7b=hS>bE|RJ#>9A9BfIIiMgq6a*oe z-C4!w8o;B073l_aS;(9y_BT{J1F-bfzeI6Tf1vzOI2At1z8%8fJ5WfnR3K@YRhrc7 zN%~ZiTAAduNRHFQn7Iqhf~1X_BVe2+#!L%yERI+K`x;RakN5#+{i!GFoOkvL_AXK{ zA0k!95zMn17D?E3dJLr5R>QMcW*>(6=8!XHWGk#i+{?KFFH3W?2rnz5)1G6+XiC7J z?g9To9AopOh6VgehV9zN$H#2Z{Bk9q_88Q^ITqil+7ka}JjxC9Z+09__Sy9>ga^zo zPi28Y=9i} zHnP~dHwqpLO( zq$VC5tt}IHn)({bpyI4}MV*O{b?Y+6{7mY?*lA5kyA>ri2rQg9+7Eoixjga}(8l41 zOg(Wwi$I`n2`Red?N()PxqA4*j<}~Q= zhLzN?C*iaNTga&X%0qD2(xqtRR`rh(`Xo)|pl;+l`by#KC*-*#JB9esd~7Y5&J*53 z^Kfs%1ilRL`tFOo5n zTBC{C8VH%zNvqr*o&VK=PKrlfgxq#j8T?GOB8dan>$WSNX%bY1HwHy(h`m(&A|#@ zisu8o67Ib?;cyc2U=SDd3(o>f9)`3Vezm(J4ovRk8%VIK7L&I!Y@;2D3DeEi7Lz7P zR2s6nnTC5)GB_~9+;?OQlzE6fIysqug6Pf6nxBw0ka_~}L=V7Uu-0U0tbk45sf#c4 z)y{er?Z$nzHr86WiohlEeA&q`N2cFWfHPn444e@(oP5&-|}5u^n?{udTr z6?n6GiROGu&SZc22MY{a*-6fqzGn;P%N*{~JK=l|H2x>g=WH&2w>mVPbiOC)J_(M@ z^vHQ0$KS)FF*r8U2fp&q3jRv?7E0_)m*@URFY5FK+_wVWNrStkcOznj-TNHweF|^+ z;AYDcHok8hE0=s8ho^;Ffdh_|6vO}Ip*FDVo*U6$rvM!5G7lUk0@{mRv0h&V-e1QZ z6dqjL`S&ctYZu*S3c}G{%$*acCiG*uj?23u-DVEnYKb2Q@|>Sc)t~9UpX&cC;MoWq zo6$xiXxa>#19!g9OcBP-!w}CygZ6xfhtmp&59rE`#2y?|0zNocB|JeN_)hZudx>1k z@-iop-b%l-v|RG}eV$NRDyA@f(o^g@dJ67`bdLjGJO=PUsD2iHu&vD>j5b^{$A_pm zleWjXF?XV#p(}9Pzc+tyb)%JgGyM3xs9~$A6z@WJw%@;pz;sn8oZoyk40qK;TraG> z9&mjVKE%pU<&jvTU~90!J6{F#?8i_}1Q;!cmumADp(^=QhtxW3Wz?+4$|Zqt%pV1` z8q8E^sM`Gx*jf95r@LsrV+~9t7?>K<>tbIM&^;-$C#p*iYRr1=K{>#iyI>z9Ap+F< zCL#F(kt{CFN4`c$7E>+s(SCn=Hze)4geuAC-hxK>aYEg~9t3KQxzK~lXyAfd)uOs% zE^Q<$W7`k!Q>YiNBA=6XaIeYpoS*-n+M7p%plzbP(etfPflUD?{k12FA}Gh5$F*$Qf9Zah@)FDpKUdfpJ4NDD%3L)p^DC>g}A3-L}9ewY%EZzl29f15dEHzI&T zghXwfISEk_4`W9B4i)9-V4?2tK$}7(tAK#PXA}t(b|)PO#7$|;o`L>(um^w&lO)ea z^ZQ4%1-LdTI*+=yb3Yr``|go_ZDL6MMj6*0Fg@w(o2l%h;y-Nen z`CnKU^#`;Q)ZQ}q>*z@@Rd>C*#0Y~R{H~oH|97)n9k}XQNU*WvzbGh}@*^nwF^Bj~ zPl;cWKV|8u-}7n(IW0z|o#vhc^i!q0?f&c~82Mflg9GAXpPXWCi0g&eh9ZUTlizmp zklmKDcIai(W)pzXCFrA`)OR25rQvygM5bJ>+ySz zH+iwp`3HTK4yuTJ{ui`5U2*Wfs{I&x2=U_+xoScYqZb96z6(q<3`zV$OP%HjO~N)- zAY9pLPPftg`K5rO7ejGNVzD`Tu~ZFbFVGBiN#vxhInRZ$)SPbT8`h_>o=eG6^Moyv z?brHw!enu-@TEY7Er-R(?G=*12Ppzh{*Dic>eN1!8*zhp4!J>|H3iND_`_Vp&n*nsJY zj#sJ+9($Xl&y>F|;DU0{WQ_i>EpZ`hh9w#N`(LC}YO%cG&LpwK_rEkr=dHM3W25=w z&lDcfw}e>Y`(I%zmXkDt4tc=t(7xuvXfUmG4awX>&DUc5{uf3*W@Kk*{c)PlV#cxc zb}sAfHUTmKLYJZ8I{|#4NsHzQbcE2V7L~zIbJ{?R9OYV+Ti~>t?~eY^U+m=0~+%X z`FxzZnmUTZ#Oc7FJLa{rh#UV{SdY9XDm$oKGLR5%A}-zl%bRN%{D z3|0kv6?-sPSZ!*3cSc2kRvX#omSt>^IjTS70@<%_JSvQ>Bi;gm-`^d{M z-uG5?AR1)6+0=jz!V)~aNC>v5fduPtuPG+0sCT^RgWh31KoqgvjOFhDg;swdNq?<9 zu=RgHy952V95pc*e(6ucVvX%1o?>GHoNkFQ2~s3@v#vc%J?u3{h|owu4EVif9^)LBirIB} ztrX7?4R}6xh8=&!l4 za4;qmQl@cE0B#M3PWIZTp)?=oE=3h%A}IbEQtkYX@Cy{bR!9%VD7d$D;D5V-j4c2e zy3FtP64BAMFjsW06nPTSS%4)<5uK;-P!vSxz}ndc!wtP81a0FzZq~ zMW5__jbz^BaRWM#n7-Oz&tD8EinhvRl{=@it#J%doU z>~$IL41r7`TzGOSYxo@G_rDRsS>p@zNc#?hTXMi@Q(9*57+L@>8Zh}GM2cH4o z$V^mb$9Sbtu1|GE9)TCbPsxKc%7XW$W9@#9oT$z9Q?99E1z|0TAh#wEvF}kX0kCE~ z`?@4^Q7g+c7VO09O)0k}Hkz+4W5ak7e^qF8@Z~gG z>A9~4LT7j62)e=64E8E=7+A#5q|0Z~Gg$En01>g``l=qmq0qaFeH6H}NE1$m>vpH7 zL;bM!yBF%jF%c?-w|?B+2`t&<0Q#eBDv_6Gg{#_gCrMmKEVX>zgGvEtL=fwT^;h^W1p6`yZh zi;uILui)|lE6z85U@&>U;e~feabJ!Ai?_%10KFTd)~FnOjM-_f^M~_yKATc>FTGiI z|4--#-1D)LS`C5y#H`2oM$Hh@-hff8*>ozs!`UOXTpdyy%xW!&s}PisUt)kmHP|z= zhX94x@2G)hGg<;_`TBQt4{=Ul^C4+{$f)XJ{D zfmRl_lNia`alC_;UP=Be$HQ@e)&(Kzu>($zIgj|l(VUzk>@bwpLj-NOd620qFeQ>N zkl>ldsYSCP)`gfmTNBmGHyu#uUzZ>W-oAJ+v<>EDfQuuf{k8bOWF@-8)?Z55-yHN; z@VFBIf4aYRyr;j_gD#?03G`Igy3K*tQ$^a%0{Io4tYT1yf5DIS1E>VOsWxJ-xOBG< zjjXN-8PjwrA}e~-!eEgIjP5k*zrnAg^?C@8?;0$2)#8`)b>R zY=ZvEJo;>OnBkktdMaCVe28a3EOID$_hYBUGBGZ0spUVVefSCgabS6_hokk8=3dY2 zq6SFC>_11vQuMZ4CKvmOgsp@M<9l8zZ5d#x%fBT3wC$HzS~67b8cl;x4BY^_>G+s%tSPK9e=kSIb*c;U?BbBZ`@81 z5F0$8KUyCB7P{K^B7cIvF?(YrPG$%yZ8Jlk;Oi1ufzW&AWsKa?Wvs9FQ`S`O4tz-D z&RSmAzM*aUM%F*Tjw+u|^=KCc_eB&Jk(UI1KRQq0CFw&s05*cz%>dH~hSD~*BHk$` zDd7M>Dbl;msicn_1mNL@;s%skBBMX<>hhUljP*-c?gW&BISQ^Sr;Wj`PpITErqBJ1 z42J<F)g7ru{X`|rV*=Y6Qdz}db?)b6iAGd|$E6u97FIDa!f7_`Lh*7A@R zzxYUhLtg5p+s0Rh>0@)h3~wuBZa2L^gpYCb3r^3N-Us;5Wgw5ydF_Sg$XiC8^PIpL z^MaqgG%pl5Lvk2j`04fint**o9>yUB9ek1ZAb@N0e}un}@%IV7E`=9XaDT(Um_Nkm zZZ-(h9iBQ4_mRy#jE1w%fzV?1CVP!5rZvOe^qIxT;*5!p;KFnMH?Q52uI^_@{H>vq zJ0$B}y^-5$CT`~?Zh}7M>Us{CSK0Ma9pP_4VLOPFe88LRRs+is(KVM`ckdXwB@g?x zunI@7)mc=im_5#Nb;Er4K8OformE!1FL;}{o}J+T^83S1`n1J_4U8by`nU~ng?oud zbJ}BH(Cz@WdraH?X&~tubb{D`u}J%?r1jdgE=l`Q(!S9&8rd-){g#cy_UVsff9wZ= zYgkO=G1-15#pCDCYB))8(tjgBi8-)sDd%a9P!kWO2151oB^GYRPf@70l|Rk{QUsR^ zP{b^ga(eweEQi+3b7KislkjF5zOCn8kI#c)3+JC5fQ5rlXz7Ph8Zjqq1QI6ZwkE#} zd6XM-=3}VS3RQ^}re#ETvUgH?03lTW4gMQBN3M}uNUb?I1Hw~&0jEU{`{nNe4Ds*) zTeL~1Xi^nR;pP`}!cB~sa^%2uNspW(vMzZhsKvP_02JkiUB#!CHNtU1(S3Cv+dnB3 zV*j)_`*(mF^Ym{?VufiLk-vhoz*DQ?n-@1?@l!B*PBLtZJl#+$r(vBYJrt`)x9b#M zxTS8BbSf7(o2RQ~Fw#Wx%3SHSkG+APyHhd-=nE^G1Ga^{*-v2nJZ{?`PmFdk)e{zlv@adP{2y4jl`PciU>p5H{ z57$fWY*2$;&%Rpoe3IA1BBu0O%N3)n(!6?sJ^>!4)Vo;gb!rioG(U6eG0|*1*BzSS z_8zgdRW`{g-$w9}N@r`BZJ1da79?h9SQ;(RupoXA!Vz_DJv@)pQU(*G;Nrw6c27O! zF}#_j?fy1<&F!f?el$E@YBiWjDihwWg)^t}U)UcH+x=NMtJ4o;D|A2UVXrQwaB zAJ!~6UIl`3-_BP#F;RI&xSgrk6<8O0uwJH>A7^E4+t$o{uJDW%W&|`ca6lVWC_p(} zhkGOx^88E%k%vSmj^z2UoFg`aNWnNW&rER>B^E+;7gRMtZO%SPty4XYcqPK9ba*+j5~Kd{<=R%Me!kFKzr3z+=xxj*HnWOa;Og;0>C~W%@j7SYIVG(o3uWX{kKHEwfm*VeAnBN3JE2u?K zW`!0Iw3@U)vuQ(^X?5|*0=)v%C7sF#b81Ci4 za0eH|J&9pgmdJ(yYptb=kF1N9k%88RWY#_=>}+CDTuq-34t{@>vIR3r)A+8XS+6BB z6QlNwX!iJHq-2-ov546Vs}G>O;{}+m#b&c^nF}z3LZ!Pq=57nHrBxv*z zD_O+6$~8UmS7JM-3mQ^WP0Ua z67RU!TjaChFwMNl7MDZdAO+iz6{+8rS{mIsb9oboTjZ7F$GjyX>J)g-GEeK|I;-j_p(gxhe4yD?}4|cVv!!38hoAuhI>ejwk zyFeK0PhbQ=u0uG|iaUd%w;0VSd6~5lNYzWZ=!!WI6>(`zmT)F)SSD!?5txc*QD}a- zE2U0Vxm%((UP6RXbT(IrLht)9a4`)M>}ULEN?H&;*u8lJDXy$V3J&$ zGmpw|J1}o#@?(f1T!=6ZY2!{#Ahg0fheV;5k3}L{q=DgsZ}Te9eDg7=E)(?yq8x7H z^C4UfBI+&j6V4w7N7K9{aHYH)@JtxUdh&&~1spi;d`p?xVnndz#W8d4S2mHDV02@i zc^!fT{3YCoby|c4LPaM``bX@)m&=jK$%Bzweg@0$KA;mzwG;9a&L3BRPJCZL;)w04 z_GkR4!K3z7pY<$U@igaON7Uf6 z+G^)3CWT~r7iM1(UTtzSkMm@{z|2=<@)uX{pG%|C4xeDX@NDU~BL>I%OfsR;1HC$i z%yVX92#X;7(==V?z%jo?zY)VMa+UdP;TaJ1GkGHwYi#(*T-Gxpka_IC*>$c9WX_Uy z!uhZ2v}T;FAk<6V{pV?3_IRn^k|lXfEMnT#<4F+5qZC9R2{7^vt=rP4%#_5#a0^3} zWVS+Lo~d>d`_%ksEA=d5-nM>K_AHh39xcL>#&0pO3Y3Q)&1apdAfzm4nu0gdEJvYgRvX(S>mu!;p9;bk6?Dt-E7 z_w7WgtkGURQIsx#X6bW1iF1j|GX*F20>!uHz7P@8}` zw`H*6LNi~`7t48OY@nj3*AUMutb*p>hRdC9VyTA}15y?&y%Ld!h zLJ~lY0y1;QKK)=r_K&Ym}lmmV-qFzmyIIaQv3mgH@mJQ zwXX5hx(wmSgt)cTZ<#Lrx`jEuA?IO686 z98&PjGKgVpNH;elCX_vpuVM)&Dn=TEmjc@Jfjt=Y);AFeJzy zD_Lf@!K&U610U~=ji1MnF|aOvOg8-jm=1n0y6`w&~R0T zIWiu}GUMHdelDUF5L(SxHm28Qn^1Z@;!k`#-7Q=W-gCd7MLzb ztA^3mYmBf|4WL9{q~PP+gSOR)wmOaM+TjeKMC2kpPu$`t3EFBj-=P!I*3Xz^c2!)O zQMefk_*v#vKdmHkatWU}0D4uquVOz5a>7IPoS`^@Mpfm3AO@Ip^U^xiLmb2jZsJk~ zgkuv)hTr>Ch4}N&Mz)^7)8>b5(|cDNe4C z;{1mzKY)w#EnIOPHdH8b=I>omu57}aTQQRvg+kTD-Ki^p-}-!hLQ=bo34 z^DM*-0*n)d!709qg9taz_Kfxhm=-xxn0h8+I=kX2`fJ@@>miT<^rJk1W_6RgAtyXa1npV2p@3J)5(BZgNXQlB^ZFYlwEUGSljXUdcK zO`R^_a}TseV0Usp#-B}eB$LJ;p%F?jNDTM1;KxEIH-63(;R z^OjaXcv@&b%2bFKYI{|GC#{rCUj0NP@5vtFZ&-Q?xD?-ePL`Jeaj(4HQ;qXbiS%{p0|LUSpa~$2w*D6e5RL-4 z5JutJ{t6zXk`X}(RD&K0{aL?2uLN`e1V&g4mJ^Q#AHnQ1{%OI`2XK!I@41GFa<6JP zyQZ6e=0)_}vfsH7KWJ`(6ydpgIe0w+QO~`q%2NrQE>O35e?E`N@px_lkNEK{{flTc ze!sx>kLRUPfp&po+kEk*UMHHdi(|3#w3at42c#f+D?Uw^TMHh0kjTG@#3D8S*nSn5 z(qsLhje_G}FC^OVH-gpJh8P2+KsUKn^PU#;NR7x9Qe(D8Aiu{>exR=Wn|oXKU4sG~EmB>Jj%v;ieo581QZIDO$7h zO#0niKk*x!EsyeEg9Nf{KuY~90w(e~&o4AkV?IOxcbZ~Xz2K1tS5+xfjM*Q#YTrQ* z5Z}WO=*#qW!I|jS&11(0KX0w}a26=q=?1qZiwOx5NDG>gSP#VaP6Zzo`T9PIDZPoGxhtxIwcrA&v|Xz9$aN!)&n(uBem$?PJz<(nBsq=(COn% zOs9{#K<4^R{*4!iPWR7Moi3Fk6eZE=JVfOR0KH72E_TQFm3PWTeY5)OvET3VcpGLv zw_u{<+VPid+SN=;=-L2#?zM-`S)fR=JzTh^nLeTJh78XE$z(n+u6Pcvp?U8Nwwf4fS_K306y!^@XGv;XgEPD{nnHh=hLhhV<3CH{= zmjhEbwZME%de+KiC`W&=k|jf@e1eAe%suem#T{h8|3H4m^xq$b!nsZ1yh1p_47BfVAsq`eQJzUA>rnDgNGGcjv9p5m z^r8hi8Zcybc9z@Bua6`XQFAuD4gK0r5N8JW;WTa1$_lK>D>^5qF8BQmlv5Ud3Kn9M zv=S4!^trqM=@fuPb+{sIF8&O7w#$dDV9tG!EBPrNPixNzly>t=Jc$HKkArl%?Y@76 z;)mlnOvRxa`Kh;Ma$wtd8`WnTSl6j#0zi-?h~;W5OJlNQ;GUbU&C|SG=2;qE3#U=Y zQx?FtiYV%^2Uk6*zum8jo+Q zMcCBIjJa7o;59g<;s`yf)H2(<1)H*Rgbw(y($UIM{V9AVM{l+2Ez-bfJpD_3dE8505{JjC3D(xrOe(-V&p6>>?jWVnc9d=)V z`MqXCUo>+CixDJ-|$Q2aXg_uxDx^}Ae}|YbxVkgBQ&&QrG8zV2VgO`2v-ha zZn;J4a@Wu*?^6wY4ej#xAOaWVqj~z+)6`Aq-_B7A(r}SGLN&=xYJ@6`YqyobngvJk zw7(i%@CJIVr@UgyUk9Ok;o;MYliV)8H;Sm>;FN1>{lO^_2*%uGEpYyN4+H0K?Ptfv zJpt$L0_V3&72ur3a2E6mrd`6LgW#rgJnHAf(9cU-nz~)>zO~>)T=bo{2Tr+-dPq=O z1p1X$)4Ti-Jbr@K&2gnWC6(@5J2ZYp?GT#I(j~-^YNqt#+Fq}j(yS-*G59g?5U)Co zEqGZ^ZW#`vn!y8Es<1-vL_<>_8^-dXCj1m+zbaX&H~M#)>fSDy>EbLngGEg?wCh^c z&|o_GZd%Dq@B8Q)$Tmr>vG~D{+h~l{LZ{4w*K=%ujChq5w37+_f=u}4x~R;161Z7q zyQPsdd=K~qp#>g7`f(>5WDweIX#0rr=zO5P59xSg9ZZmh-fQ@(Vtn&sK>i9xN64OP z{I8+?r^w)Sxei}Vl=xK=Gw^sD9T7aNZ+FzFZ;uK@5z^1p7?degKbpbXBu4Ex2D$< zgaxh7MDEX4W(c=9|C`ngj^q$QFpS%xc~pY?YA4wkcae~{#7jsVylWflldsEP7PR+7 z!$IPd)PP5gfcgY#(&S40xH$)?7~-ZJ#ZTa~3=Svgy#f85tT2iDO%I@XW0dki>osuR z*D8oKgjn*o#e{OBSptifD< zZ+z8D-`!C$?EG*o@xvrW1s-Qk2bYLbm5JL%BTLT%r*&2nrxcxB2U4c!WTD6~ z;I=h9eSiDrH6%y01$##PeEbymWox@b<+O3uKh|=!{X0rE&^e697rWFYVA$&L1hzZDJC4C z=rsLjGMK2qrT#gL^)&VM#Mgyy&Z6+TB@4qi^y{vAZK^)^_<`whv}hd9(p&0|faKn$ z`aJ_WS=$@-Ofs9@9r`}WwCLUQ*-P!d2x^(jienqqu!E|L zJR4$YvzcMqN1qefyeyKc69RcF(B`k6pnxabSRowxREja=a=8e)=zj`!sVVs_`f5O5 zof+!0!+wJ4W4WuzE#_{#m5I_FAxpksWM2&KM{|Nu!(zYbFh&)NR6F!; zMfPL*HRSFoh$(c6oQwV^m?{^+BrG|=ypaJ>ve9~XMU#HG>4YEmMsiH19Y%_fB!c*! z30}Kt`W(pF=j#GL9on6tg=RgOs>MO6@ESGaqnG;3Ch%-ug(2m`ARg(OD0eRD#oV$b z-8z)1u)2M4+=3H^YTDiS1=|izX)tUEMrIr_F@+Wem+4Z+xON*~Ae_ai+MB4|4uJCD z{Ho^BkHhUrmg0Vw`ZSxde|udrLk&yLwwxt?)c(4r;vK{4bgc%%EF0i`(q2Akxd*M~ zbga~ydxJHEf@I6f44bdqJACmG1Na>u7fK%Fai5FllvvzW=p694Q?&wWgMWm__R+5T zs2Uzy?lW-0G#-CP6QZr{NBz?9*vIMJv4VO%9(PR*c&wxdkN2c-8jqiTZ33kQlQogT z?zwylB5}al5~Y58SUdQvMt8kcv2mlCp!}epvv(k-WJBsgttp-MDa< zboom3jh+gY7ppU!H|C>Q=!mz;0&TU_le%y&kO|Ps{6YAxJhmMy% zIt82i$_Ciw(9cF0z?T@=;NT8Gra_}9c$Trq#yj{t>CsG_ux~Oy4NK;3uOTO{w$-jK z_Mvc!-yMC{+sUhD(e|xJ07#$YjyzNt(Bpn=zvd1boTpZT$5XNJSNDk#qG>jR5`-P^ z$N>0$wmGZTyJr!Qz}J6psfEn`&2}|U9!J5>+I&M!0kdaO+^wh6HrrG5F?V>|&lQ&U znrS|7mtWe~cH1jORMLIPw}C0Ax4-m(5TQorpH-22$Um#Qu8-%QCHH}HOjp!9rmbJp z+5U3 zp`*hP>!AwzuRQli_}~tEdxP(%72n@KTeW-eye@ZH)Z47jl-rk;Vg2_Zb+hTM`|LiU zIlZkybk`tYXMkNG{I-nuEDfo6wf!(>`sBU)k%WW3{a2nTDv@zs#WrephqNjmwM%0q z<+OK?Bjw{($X8GgI}#`jr>?d_q3RceAyoYzKNHY>;wq|Cr*8hKk+Bu`^$mVYr96rc z9T`19riS!sd2Q4FH&qa({Yn39)BZ>QY}5X0o(Ije#yJ)$8axCWFRHX!?KUab`dVyK zzTls2QZ7-AkIQxf!v%z?29}2QE7bYo)oH+N0=?y*B2M4JqKVM6;j%RfSDwcQn}SzT zsnLNFZPwg$xF|`*E3Cp|he5aE!w0$AO-F!SR+~2Rtj_gh*-gh*u_fJ0(gw=5;p$9d zj#_o+yh#lvy?}!-|50L8e$gVEBl~)Ajb^-K@+UpkTP+9K2Z^m!GJZJOk7cFaL{PxZ z-H(S|UBA{KNe?3Yu26Nl1m@z^_7gtd1 zjk;Z2X+Irz3`<_T(wlp6;&LS(9oc{?!n9iA`z#T)VZz|Eo`G5g^L<(F8rHB1SJa^2 zZJ^Z!cxyk$)=Ro|M54dv=c0f^Xek*k8o|=yVndVP; z;hrp01~qqRGM{}u``HP}XP5c*&lo#rB=JtH#4( z264!{CR4fKw$-dN6S#a%zF1HRbQ;b&?lTBIjXtQ zj%r?fjZMN-_jW21nOxWmeI9$rl*6*yXP}y#W+Bfg*$Vs%?U^ILj?!(Rxd{JGlmk0g! z*{>S>)h-$o<}7ysbhP%ltGm^GakLiShaWMX(1%-tfjD`@2y&NCgg*RCLw;N6fErz{ z1QuthlT(Lve#zPKz}<8n{ULNAv`gJMm_+8H-yMI~ct|1OQxrc{3c*?+qHu)>IC`l* zhC@@El0NPd_3_=lk3Tue!)c-w(V>M8sfRDn%uwd|+51zIjRZE7WiGeuXH0Z?19Af5?7=x>5HVkTc4D19JZV zu-~8#6tqnpjwV02%t# zoqZF@KlE-3hS`_Sjkw+H1KO*mk6p3aj)GWC6Ns^tKG7uNiuCCd&D`u{$PkQo^YAPotHQJu-^EHirV8%)2zQ z74B6c7B#bQrRiN#!`d$_)wG@Je(X~;q@d1!0^kKz`fT&bK{4Oaksife_6tK=Op(EE z`Uj1;LhD~5e~F$o#$%O#nex?WCl5@QziWVrZ0mK;-5mPSXS-e6f)>94D1@e;Ha{9o zALg6BK?fvI^>$P}ln?DH;WvE4@k`BO|pJqF27+~t^Bm8&seb9+jNjC_!PlzZ!2=SB^c`{Nrl(sMLNxy#0x(T1z+w>#;;iv17N*9^LNwZ3?# z%_@zgt})N~IAYacZy zqt8noT>O}JKiei3e?b>~aOtckphRIrKl`6%6pyWk;QRAaYuo+}>hEW=*}HS--MK@% z-5Iyx@%py;i6CEY-~A#9R>()encccVX)HYAFR}OL+wHx^JBF0(jwHzjcnAfR;Z9Pa zVtu~A2?e@#`gl5#hun^DgoDFPr#B5AM!VXt-nIu_iZ&wL$|MRMi&Q(;SnC!eOIu39bp#yyS$3)1M=Wtk=VySF;pF2~=aj2Xpq>nYmlUh5<8 zeK10vbFFO*+^BkTSmE5|)4l>Z&B#AZL+Ojw>dcdN*v_iaHhF=YZs`5YkUfOUQQc6u z9My4sddLcwqe2MYlk}&X)O8;yx!#`X+pm10y5#QmiI=->pQxd`n|U5;5Yk_~R5NI;gE}s0!|Gb?nZwMT)a~jBD{j&x6=(3nc^$WmuWc`l zgAQ%8fLXz#orf@V3sY0!?*ad{mlWGCWdnjw&OLaOl?R7oc@^j-Q`XIo%cTdD)|Wg< zO|)`T;-31xRM3Yv$xCzxvYg8e2lK(j0k`MJ5KvPm&DZV1&ONb$zIoT}Uw8}}(yx=$ zv%l{LYY>n7@AWZ;99(Fr`v3MHZ2dlBofhzDkVR@W+TR{G^U=jTYA>?I=J1Oicg&@e zRO;dHsg!Q+fK-Xdo5o=f(;9Bs;I>nLFm|jHrZ2^C7K@<1S=s%Tkv`DN==&nZ!>?`es z+YY-+zH1c&bKHm>N4{!ce9fvKvclx{-3Gd9*DaGX+~-v&r317i4Iddbe1UKHuLt>t zPsldBAFs9(&HW}nPN9RBY`Io$Y z`?C((vX1#JeWATfe{TP_A99*LtL-08*>hvS_l|jK`nvO40cJoR(zQGW`ubLqdhqgU z@Xqw_B$XCt(xKvhzqv$o6?vcKC+&D@J)A4}$>!!$w@QySpQFP2)X$Cu@8Lq*^HAS# zvF&;H$FElFT_rvsw8K7qQ_Sd=NFG)jW_VB46Qf?r{sEuZk6M2ELHin{FmhwVSNM$0 z<}c{is+9Hu$>RUs?JDb!8 z3KnNAKc<-Lq~lV8W)+^~zAE2Z(6#*K^JiS3!Lg7+#h=t5WGN`-p7Xj2xuu0G{#{T| z;&T9XXd3m+u@uw9+?RZdrAu>9gdEX&pZl)b(op*Z9@HOAVx;~obrZgwReu8gRFTgS zga65=1cL$X+_0qfb@lF<<1EcRd6GY1Mw-DNc@Dt;P00QMNfM9BzTTdVvE8d0Bk5el zUbuaM<(qe+8vi~2->c;}Co~oO>DR$o4cVk<88hH_l=ZooUKr$d`F&8s+n|hIh}7_lJ$-`W3P8ioLvDAlShk= zES<`#bK8-qT@Uc&cIxzwmV@q`0@1j;ziHYXoBK|cg!`;_!)baa=+f) zuL2BvEx+ztWJKX6Xwi*yYcL14(;$)c)}XcXWeUT}B7Nnwh-3A;6UeF1N22?vyc+?2 zjn^q!ybWH*mCwHrc^%)zBYX(ITmQ`B8G>QIJC`(LSL->UnWL;`6uRA8cZWEQF`exF zWQqME|E762o0%g(GvQso*C>%)G|PDK*LY{=QAxAEc&@V9O{A4KyZerYpI9rQ+4OMB z*Gv8RMt``D)=j1G{3z&G+4D}GR-A$7HTlcLc1Az%B>5h#K6aE32c3z~)M{7!cHOvkT_?C+Zrp+-Hl_Ufz|=>*#|2tDP3~gdZ1=i0eW||h_!es}zMt)z zOs$Us2t>d^e}&c`4K>mqJs8b4MfD8$9;|Q&eJ#yTvg^6%pJDPe11bI;!3W>(6@AxTKhEA>FN78KZkkBK~~?k^cv)n8IOn!hC5-}iAHn*tgDX8XD(oK{>D zgSPi;j^b-{r(bJKx~)FnGrh?uFJ3%d%s9jPedr&OI~Bh&$;YoSOWpwp&Gxxss84Ri z>p2_1-AE*sv51>Q){00$MLf|!IN&~aA!&preVJdIVXtuB>b+E*sy!e z{$&m0E*y!0VQi}gv+FzZpmvdLKwRlPj4RC)=&}7V5*{E5wkYhA zZ&Wf<^7U?7d}Pb zy05EVf8&b*v95J8` zVbM*~r!lgbM?BZ|1Ob;iK_xCc_wpG>tPdrb6l{%aU<107nv&t{P*rPN2CV+j?|Ue> zfw8oWL+j_eqv!`?vJt#uF^=IGG^2qbs?3AN`Cs2=O1Q;dT7aK|?I@_7ZfgM$Ut_E3 zbkQQV$KK@dA|+&nJIuc2#M5i;|l(2igQ| zuD9%>Grdues0?^o|!wEp$2!df#RGH7p)hyu+RC7Vy;~X z;db?{6=$t2+`}DHh1RwC)9=m~v~^eAZSMwHxvoKCVg-rX4g9s$tCIDf(yW7R-(a%E zhY3w&kPxyz*q5B55JNt}uCJ!nW1Eo?B}i(xWoetThus>f9YxKtm#N@@bOk9?{CGdhjxOKyUl?-P-Z$78nf{)GJDrMZ~r< z-HBf@#Fq0gtWVcnJ>Cx6WVAJYF`zj4=-mvPyP9+->qhq~iVPh?&vDm3#^C|}!QexS zT)@|H1&C^rz8F*pO?Vzre`HxceSGD}C zJpJ~c7--LQ)GI3LnJzY{-;DH(HKIsA1Kt9i)+a3fh<@w0`hDZTL*)Ut=16K8zcRV) z>^Z$B@*p((f1NdH-is#J zUTYzwM3&DiuOY&x$YVo;QTyM>b?xeE0QgVH8p`|)6hT0>q~;y{$u#-6a8aU ze|BOTAwN_4_y?tb(e1hSY@9CdYDb!CE8%xuuX}-<_uQYr?gaX z@_|2S-~dndk!Xytjfv3M5xw)ZLO-0Z6V~KL%r!<8Dn@mNOE1VNSfo-rEb-_0+SM~V zCcFpexlizaOoGfjE&H6y8kKn~aX(t!ZCa!@^ACeR%F+QBGSvBNUpt!+0CW>K_`;^N zKcr>pg)c}>G_1k!8Ftle6{0q|`5bsZJ{D&9@KMdY|X=P>VJF5klR!44#ZA=hG4bdl9`7?@saG zG{5xspHDK<{+yIB8)asFDdz7AryBBu9PvCj;*X6?4r5?)qWIk}P;PYlRpnKd``%Tb zG!WzIR$q!=D~^7O+f`*02;>7pEBIxZedFsEQZw)>^qurolgfxCe&QVk=}&@xGqTTn zawGJF4}wqC;=jD(Ap>9a$4m+O(4#MG0v73^LY|#ZqKHE9@-RsEI9)yq-EQU=wY{;L+IhKR5>XnUi3lAg>e z{AC8qqPpa19LPDN=h#W4*0{g^`UMFD;{bEJ^B1qt#GodxXQM5syxe{85i8IkZ^eLn zM7f1Ee4)Ire_nz`n?l5uIE>}(cS@+bM@T0gPdf7^yU)O=oQ(-nhB%)+*Gojv&{5&R zDmsY|;w*i1jS|EcsT(w*wqqv&a70dUW@#XUw59RsKr~RP*Io3Vqs1RVA6LC0!i(zj zaj$OA$m&C0KW+h*ePBRIhCMLl7cKNYb}tFt7GTqg=eVo%(9w$NXR&=+B3kD2x|f>U zv)f6h(l?Ddp+NUAMDdu3zLL=My|G`ZdVjT_u&lqE#jiBKs)m1?$xrbUQ)n9fdE{R2 zHGBs}ZW4-=Gngv)J9T_T|AW3@(1xL)+T4PP4RlK;C>I=WJQaj69*+w3L!XUg@p`x& zYIm0<4#;@1J8DfLBh3G#bV&w8(9n13qA492ezTeJZw|f*zv#)800Ygp5aDi+D-%FHiqPVSN@~)BUqE(N2uZ82^akN1MQC zz+f27?|?gm2JE5)=|Tgph1cXNx_9YKeTlr+i%6*K&+WdLnJ7X3OZUgktD4_TS3G;& z0{e^l%FBZ$$ja4^g#8HH{2SuhG`$M>Pz~S9`R(TBzr6hB-c$7%YVMkyj|_b7tqPxn z9~70p8Tl4;hm^cX;DyYkb>>wzl*C!AX7HWh_j_EwYX-hsG5%`y zBy$fgj}nitCG)kl->2rIT7Nvh7YM}XkyjgCn?XHirVp!I!5Z-P)q?4C9$+#p(m7)m zRPRo;uZ#tK(8Ih0%$=P~*c$Y<%T=PKr9B~_*-!0LMp0h4D0O#bEgoedGQUiE9Dc+jw>U=Yxg2 zxC=YK-91m|8xFkZ>4rIX>!CZpr2D+OhW&e=Zg}~uuhSg{w`GNIR3it|$kPptvu=F4 z;l1@dTZWFt)Cno%-%(zN0~F zwDakPQ&zjDl#*{as9Pgg{mjwi?)dD|@sv7wwbJ|Yuf8Y0T_0`RvIhtC$mZ;@MG*HZ z>&7J2{49@NrPjIj!mk*ie&!Rp>>64v5EQOB#wxjRscT0G9ej@jPr$Zunt#K#Zs5@k zJgx^Gv|u92>$5%Xvq5(S^xbyI0#$i^wn?+=bpEUG?SuL)&SG#Zd|*L@M(l{uf-m}h z6$yvx^5r?<%LDlpPO7$}td=S6OBx6yqMCI`h}0pm;P#S5 zXmOvWH0;f5Qe@oT&MQ)(SA_HFNTe{I)1fPE#?#W?aS)723Sy18 zf|KVTliuy#!84-AM8v~03xf)ixysrfaCHRptZS*SrEWSo;P#~XI0&GS-V4R7AQd;2ub1pB19f`0bd$@+v&UO^9K_A!nZ{KvKC zE*=H|Ty|hIP@FZKq7>;>n98>-l0IV&SKxKFA~Fh6ULhi!ujfKevOEXe7m+f9N1C|s zSq<$vYLYsf(}6AK89h%WwccxTWXt4oN#A^lZzAbfGU@nBr62_%QfO|(q~k*uC(^Mu z|LWEG?SAG?h7k{)t2z$bx_1AdZ}v*H`v+_HWodAMd7O~cKuw_RaR>QnYPLnaNZzH| zhac8EZhi}MY4G&zH!=)ABS^Ci)9Y&&>^ZY|xEKcCG}`)SFf-=R#t;>#1CR`BGPvbV z_YM24J_(9c_-`KEAePnRei6!7;g7+e65$_b9K~fL`fH}Mj29exvHp;GZ6lMsF?^+M zrP5My6?j#h?-V@Uht7wwl+kbb{Fl8)_GKeK}deM5S>?`@C9(B{yCm^Z+W_5YP z3qbhHeM4rU$>dN1^uc}vSCCDd1Qi7ZSM`5O!!b2_WN0r?2xaMsTDKcRzO{w_J79I; z?k>7qlmA62!r+X4ns2xRa10-vCeaFdE(+<&@IOr-Lo(Z{=124mk4C;6E~K?`3G)c_ znC6cuZ}*diB?57LSNVF9;=9U?H$G;CJa4S=U5$9-B8Fa}?>m#X+5VQd&l)ybEmOt% zk?~u3P0*{Fsn1xXh55dQw@CSqnhf?u89%5ZKRryeo*Gvn_T;~p{G0;k0EN-pwZ8J1 zpJ)|JdLRN{N`IRYxGav#oHo`Bevx{t+$vvAUGH_@_b(;O+4rX}c%4v)A}l1i)wx-J zeqj@4n#CV1&21c-HN+%|@3)AQ8dg#5tWv|O?T+ZxIiDL@{iA@qsXi`%&WKIe{Z>?} z1t5Da4c$uV+DmgAqv1_S$5W;8XLlzutG50=LQli``{?;5?|!K9TNy9!h}VyF5GX%c zKRNnuM)7O~C`sGY#Ujc2$t!#%)z?p&V|n!V`Ddf`4@K%E{@HSTDSMB`;sv4vHitVn z)QXe?gV#~M}*=0>PPEV*&6R>qfw>wvmk#xe0LWCW#Q}F>zFW}?P9_@ zA3A%_0=+>ABDMiHpNfSGli&6f>BU`c7*;m7ZoioOS~ z0Na$lm|hPP_~b!QY>D(=6DZylGTu{`1+``PeWVK+?n&pR*QmY3aD2Wy*s+=NY5Ll- z{x$kO)2E_hsj9-;@Wph7FULGT(%1BTT37S@?TLivm-R2Er*%25q%o9k8@@ERNuy!^ zlK*au^)6r-?2qR>{-*7ZME{yZw~)M2Sy~azvyjUlUhpESUqv>JSr$2WZ5f*F^Aw zA@5>7kL95NLwQx)s(DS|8SrINieISzl1I@8r67ieeLOAN;IZnO4{en?#pG?qs!?hyo2}Y%3^wq_+!Zf0pjxhx?#7MDi<`=x4Vqq=u<^JP4{Sa^L;c~c*b4|S_$SJ-s!0RMGe&46+`a@K|hrd?=hTZ+JeQ^Sd6Z4-( z_I=rS#`?bA4xS+@zc4+r!ISBV_;r|i+X7CTLR@@Th5AcpZPGD1c{9Hg{3>fNBd=Qh zzX@JmUG@xPn0MjuBrmK6^jc+pwt%1go&32G^!D;_Yx(8YmJjot!S{;sF|EdetI*3< zwrBcLxqL0dj|%?)jAy|bzkyOr=q#Q+Uv%zywh85H*LXG9=xfOO>Vu471<$Q|A$1*j zBp;fMH;G4izRfQj?tr`Us~^@XuLHu0%kCqzM_;ok-_Q1N}MBJF= zP1RB}#|LmKSK~q*R?{yP*X?AMGFv@-P*F&oBk`pTAip$&;lff&>XV6D$y26+mKd9= zszYCF@9B3(14#0WXNSaLr}eQQH9}gidzI2^3I3IF99PiiUeIC|I#ivlCqxxH_lTv# zqt?0S>`}{S@pn9%y58;1_8nNp(3htQl=7?QKecSt$8P!j&G|Z+44haz-52eo=!*R9 zadyM^g2=J;UF#ylk>c)Z^X;W>hF3DNR7cnA*x##e$ful6zV58H@cj?k&|mqsRCy4mY;}y@^}h-~B|hK`+%C56o_W+_~!2s%uzv zmv;eR(c=Uj4c}uS1%Tx1IK4{i&CvpG;R>z5f_%&JVG*}Pt_;5!?dzKDn7%p%0)#1) zkL+mQo5&;Z8@Jvg%OZfhl$tt`HH+MpYJ|Pjyl}stUc8ai0)RkEgSDQ4`GqBxbvw*c zO*dFcanBoW%HHgC>QCAD3=|q7W72&dDqSbI8SdN}5SvE2SO68hglMqL`7h$nc?hy( z@)C2e{#=fyNBcN6{+_%#_;!2Gh@zP6{>cAtCBlWhOsH$ycw4WGG8j{xq{ znx(nF8Uz(_zIw3s(((06a~t9m)*UTnW5X@Ezc$=5Ys2c_)z|iVpOWK!wL_mzCZ_eP4jU*>N;@r-L`_dGD;ZW31K5AAVtHNm&0iV4g6 zhjvPR>L(Qkt!GVt(pkn+}$)C{9LP~5VyGF)99r{T@ zI?9D^6=+uDdR45>JcCiuMmIlGl;TE4?3J+S2tJi@<~sDL5gm>M!+#B}(M{IZ<`#-Z zQgW|W8f6P})pnFV;<*TJ%;wo`_ z!%oNAC&lBDEzgeZrqJ6uX1Fl7lNy!*>dq8mLlaQea;oae-i@{?1em z?6Qs}|kD}*KZ=$)b-)lPZ_HJ)4ZTFcLyUu zJZT9n>fK)Uu0?f^COb*O1T+yvya218iGO=0=S;>@gm|NXPhz0hsTMrLuNEhLFmIw0 z1%HIj#%jOt`Ih!^A9^a=aL{@b+Jses1VG z?7k+nLGko!b2gmMMM<%3P_EAbQOubWqjE-dBks8HZdQWAc$^ajM}CU}nucGF$=W;S z)L1=uNdC~?a(u9vV;B+sWZ&B#I}PU3#ngBJ7G^oj>k(omh5<~M)msay;4_hVEF`F9 zlIU%1&njX+IGIH<*rSrL03}2k80DkSw2YB@7=M4`WfVrvbPb>%|Up8&(-boEwevy`bIXQ=IPGpwQN42M>}h6 zY#fU1ZThB>4i^#Y&lhvgr*-z=k7%TffL(q6YMK4v%Vzv#`kt|;;*~bz-`5&Ac2wEFRTB*Yf%U(rit{cjz${_6Dg3M(IZ7|Z-&W5O${uf*7d zM9%N$@LnFEG~nLo2PiKEKGz z`)c&Qh5c_bhNwfs!6QOFg@d-=2wd^b#YBI|@RKd_XN`exThPBud!v*$q25EkvuD^x z^y=|f=0rGG9J0Yrj*mRl_s_xK=)8$-Zt^%B_K%4tX7yj=KQJEa|394{M*0Wv>dE~@ zFa=zHF>t+1FWyg=@XM(D80!gX_>N95FIc>z$?Q5?oJD^8=KCI2VSTom{Ma0S-&}q< zJn;%w~HHsr*wgTG<9XYJX$6_~Lo7-+A40!hJ|T zu^c{rXFxcuU8s!qE&S(2JtZYxCb1ZKaeZ(f1W^%Csw4f`AU z%`-B3I+I8*-rmPsWSiXOE{I0$E05@@k=jhZ(|M6oWJ-?WuQr+XsILT{x5sDoMT*+6 z+WV9;u{(-8aALu&iapC;ncw(~jVjjHJpFDVepQh_!+GMt=JC7b42)g^e-|7eP+g1u?#)ekjXL?@UvnRlrzd95 z^z#w7@CM8bLx3{;z|bO+YN<5eQSieJiO$R9gW(p|R&iRr4rEQEMOqn)@H++^fjby^ z!?OJ-7xSkw{u$}dW|yO%3gftVIXN%8Lf%<_G?tod^NGBT@RKsYM90Pi`;HLr%Juv# z{GbHlqsFjrj9LuV@|ggavUu0jemzqhTik}*jc0-+Q{128=VtfaZwc6IK&=56_-Pe> zwmJOGwCCYReOt>PA2tSO{P6*Mw2Ofr6GKZb22wnvmglMe^IxOymSeBiS&s3?uK1e@ z{%G-(|BLt|q4!evY|>)?ap`z_Ao533oJExAL_iw+v=7RrSDf#m1}z%X)afq*cJ+mv zE0v?8?pgXIzDa%9Mm@4cW{z$AHQU_%&aghGJw=H!c!=+6XXvVyJC~_OonJA8jd0;I z_cHNf-G1fuMR`GWSedeXJTK8s7agBH|3&h7N*Ie&RK~=9GAs?gX5vi)8s=gmQa@^` z18$|Z;(PrFR)_zU#XyexI!7l-fpaX;HS@$8VX2n4KHBGxfPmNEqp_>ve)6?wC#PTn z;7EUIjwe^{t!no@Pv6c43LYn4C-E}q0SP{p>vtk!JU;>8tnZj-P`mXs7X)1jf9%K?&9HNw`<_)Hr#=BfcE}gd9B^|C%?z!~{vc_I*5=>)6d4DE$it#aTpY&+A3VGf>QDmN=^^kyI0^W}3jOI_kVh;4jeY_7;@TVl-_RD7T ztLQhN%$W8`w!X3KhkJd8u`SZ_JN7T66v)Gr>pj2u!eOIc9n4 z^hR%I5W?rt;rvF>r88eRztOFs-vKRpc^vvljHAhP2mDX!@1y>HM1X^Yplr2~>tApz znBT`6DN|Ix`;cJbnWJwHx!vwLkB)(6npes(U|-aO-}I<{NUJ8ENRkf3_$K;|;o)9q zd<*OsDzheG=euZ1VH_+*$)i3#6fyO>e0?eeR`(_qjguniL_(q!bV-8M$$Di_$ z1aBXo?zyiT!KJ^C>?@B=emy{d9(I4$=0|u=VO@le*(Hj2zSO_rYWPb# z$@HeyW19E?tdf$e^&ZIy=C>|ka2Q_PRWesIWlXQxG-4uq{Cz8yHYKD@alhg)0bi~q zq_w!!O0$~tdG6!O!v$v(COI3tvr&}OZ?^xxk8z};|3QDsmLJ3Zi{P7#7j!yZ^(W)D zrx3=eHBPB5v#ki@pWbLCdw35Y^|aLcXC~cGZ6H~95F`F%WihJ$ccgdbvoJ3*UkE*Rcs_4u5D(*c#+^F|d6nEUq9@7WQ z`WL~k6mvW3-$z2%A8!+%j@!PbG4>Cu-S4T49L4JVUG6k>BcA-~{%`~Qw!R>^TOp6O zi2h!LKUMVL$G5rlILXg28>c1%%B&ZS0>1?RMBDeL02r+iWY_a!evIwuG^|?B}RR7-aEw$K{8E>spU{TComYG5D|~{Q7AZxTk-gMjJ3s9r!fjuJ|ma;Yr?E7qh>NeDd=1*GHuf zkg1?=qyN`=m_+n%`dmuiOCwo@{TkMz((;wD(RN}_RI!ginc(jU^O3Qy)ADF#Iwm)#J&9hhUxHN&3_9<&{=H)rTO4bL&?lWIMF z$7AtouV`h9&U0p?1-Gz#Si?~aT*Yw0{BNy(n!r~55mWF$h}UPb^54UM41KqvzOwa> z&_B&3gFw;U)kZYQ@Vp3bHzs1Ei}=CV@Gs-9?t%YQ9W9f#RDavd{AK(J*5Na)lammk z&itYLe!-Be?7(k7-{Lp>1C%~*@32$xdLvK_XdO&ndEV|NCbq>+@D#yPtj*8cHz=~} z+&A^87*&Pwf7@Q*FtD8e1?TNn+23D=FZJ#?v4{jeB7bTVFa``^1(rEEggG$>x>V~I zdEV{~eqKkV_jy(G#oxU8RPH|y{Gm*~mzOshOV)F~w0cy3`Bk0OC|;#wSh`J2Ki#=080i=|7eE<@gWl3;OU?9-lTtFG=|-^cC^n z5=aP9wnAK*}X;m5u3rjI(+p0NAjgR=vw>^xSd}`{T1uI^InhDNbaxX&9Ujx z6tQemvEIv>+hqCm-d-uU?msaL_(qGry;zccZqkiHIi(@lsx1CS^O>yYoCcb7(@QpN zozV^Vv~#^?s4oPJeMW2QI_Rr+JxgPpIf>ksc6}@PT!p#ZA0Og=qvCez*CzKx z+j{DUM*X5HesY8G728+Co>=}xd;7T+@oGC=8$qk?-~~R0jnepprcIqz-^MOw=D46u znqYDvx7?=DA2nCveMP>*PI;bL_^F*w1lX4qwNrjp=P~RspV`rIo(wPWDaU&C&~c%< zu23B_Y-SMXgK6b4XQ}Eke;y}h7h5SZtCza^W_HY4s)}sCcGzm2(oY-H{Ke=&@oJ;f z&mDQ;TG)j|4_M9o!3+pklXr_FKbf@EZX3RE zx$(HZyffjW}OD4DH|Ni7DE!$MA7zK$>IZdLc`5C;#1E($sN zD8ygXn-JlVUf&oE9_Ne#kMqubG4N;~28cW4_t`3#`1P?ECU|Rpe!v(2dE=G?B-0%a zl!)JXUXZchhQSs1!*v2h$XDZu*f2pU`(8~ zqFQT)VKGN2POqPu>pOQh8e2vU6KC~lvo?$~@U5XH%bC?T@%Vb>xHyM&Ym+_2Vx}O1 z=Z2~D_R`UX>B2weo1q(2SYzNc*Ncvg5F?=yF-?IZ+d&eR36OP+Cfj-Bk`LCQj=?rl+oV@7(CA`Qo)AUBCG4{c#z4 zp@y19{5A}WKKIOMSPOr2*BcRR(MYXtmfKgR{{(+Oewa%8ByEp-zYSBsT8WO}`1{UB z{A$(n5i9MpW@I3AfOh5A0Ecx;wAM%>60=KUS#5auXty1`iZtX%-;KX7v_20zcT&`f zt6Uasx09L! z4>{V^_b~FW{zLm$CH{xl4Zu0zjwH-z#u4j$@a{ExOP=8d_%f+Rv6LwOT%1&;d)&2_ zUKhpVM3pS1h@JX7N_=Uof6OTS_YB!!c=6@AgvZhfYod0`k$b=5WPQxDYxU1dq4Z_0 zQ&6i@Vg4je7wD1_NQxt|H2)%EU1=g%2g`A8|Pc^4CL%ZrZU94w(uVrZM zwNs+=4~m8A;NVHFNnYa>}3+i$@i^>n`Q z0#)|ArM_-JxZYjhpQXqd+B_1_3yXXPcXAMp29FDf2eKXrP2+ncCzshjMp zAwK*CcYuHHRP}q>a~p7LT}B@n+D11+5SXmNxfc|#h`FuLp7PI#()I2Udv0S`9Ba~H zXP>xn-XP*45R2SR`NuN$H$B|wd$_bG_r(_4$`>9`{r}-rM=#eJF8eI(dRqIZ>p8Go zlVU%7O>^jGp81Pqr0H>ykU(|#C7iyyT$rzzQAFvh z(4k_{PMyos(z;uSQLa12GP@$TZ~`Gp+e(mm<+9&%eN#FMl2}vSabPdIqNGB;#e%GCP>WXe$=v)W?WlqVX`jaHji5sSGSfe#9V`5;V(IEo?o zX3KSm8>{IME2z!%@feq2Vbi7_S8sQZF9(mNO?-!`gQXbYcmcpSjbdUIO)=6cA~9xm zGap3h8EvD_Yl?mFz`mM`j*GA%QKsQAQYp*&7`2b8SgvvOfeHySCt$lzBoWgYwTg;M zEf;(|pqflQY2jshVx>Bj@-4vc6Knf&S$hz=E4NoGji@T_1R^s#bO%k*VN`^^QW5NjXNv_*sCW9xtD3QtQCbWv9S_GWH|-6Uo)PWm)SBMjQBa8q-`3$-^0r77oh=NJnQFIRD1 zNebjqgbXsb?!0I2ZKY~5q zMfl=proH=UojF=wU(j!|u^98ECsxL5_v9V}5o*vNrRNR1J@nGi_86K5^D_|L-{)80 zvhd5!-x_^rFiFHygb!)^WDC~|HQyx=1eQrhqV?jvZetK3o>q@S!`;-dPm{e9PxfM7 zVtc{h6~oW3heiFbh^G$t39e($DCTTiUoW^B!=Jj!@p9 zOsmsR65rnkHS~j)qSZe4@ejVhX^4~PR>|%AjG(%PbnKZ==()!=o3>zxe$=0Oi33LkH?!=YDn`b%^s(-_Dn*zJLyozXNpm zorV84>>wFeXvG8?aF?B)MF;1eqPheCW&HW{nlx)p<8QO^7Q+k4p|)_|g{>PV)g}CM z66HNS4VDO8lg_LY4{5Q<7OUd=Q9g`2F(FfDGyV;;Vd`+ve^FQ=NO3G~?3i+_lOU7_twCH+9Bi8c}Rp9o&Qfidm>&uc!x%=rGc`;_u`+W%4eo_f>v z=uT^?-3$Dk^%$K`Ni1GXNZ;L$KfS-x<4Pqygz?SwxNyHosR$9O!dt>@o;B6u_hV=M zIo<2%Qk3**V*x1B$mJ3D$9IthIhHA$RpiG36Dsw)EWI{X@Xu6!r0-|=Z<)Lv6Mv2$ z6@NUvRgrHIeDg2CeoRI4DWW9Wl3C%eIsZhd&6)ek{CGqQo+tcW`u+JATm3NLH2pwt zFH!wB%oE-!*e$MqbNY5(CO2H=<3EVBm_9fDW~F(3yB_wR*qz&(FhD1aLV2WbPgWIM zt#5Doz8dlR_L>t^L#%J>KG<+R)3=n9)wjPyZczU^-Ft6RQLk_7d<(kDdYII5+s|)- z9NqP_6YJZL^7)XQ2+Q18b=X7o^O-JI7MJI^^|e`jJHp4TJtLO6CHg6mpGK#Nep-zm zd7g2Zcm`x0Z}ax@%JXNV7sa1)vd1R3W(`FPFnQx=(mBEOGIkKzpUC=_MUT|BEN!Fq z+_1$}Hbm651E8uOdbz!}KWWYHqa-0z@IRN)dxBrxpm8s9tQ*+&#rB+&6a>E-S48;L z@4jwRFZ}9tos2SzUrdf!7dCCO_xs#0R7r$k8mN!)?Q^%8jD>T)sb+kQm#^Wz(>csY zFFooDlGS}qZij$xC%jYj#rSsfQ!&0Bp`0wf?Z+~2jBkTB43BS*n;ebs?Hx?5b-gnX zM~rc8R6vd}?m(?jR>!yoTf7A0{(VzjDn2>UH>=~Uf7w*0Vl>OeZX0XP+8PPYR@X!oQQAL9f;pLf8`0b4LAGgdbJmDVVl`5!mdR`K| zy=S)Te7i=S>udPo$4^#;=lN-CU(+0=3LxWtZc}ELj>LxvgFU^4)|*xH*8rFr{EGc< zbRTFH7H@L*=qjO@VivVb+&W# za-U-M=>*tlnV+?>%<7GU=Is=)b8VIRQH2FO$D?81w)-ig>0L?Y5N3a1v+|a92$$CUHfbjTK zu78I1)B0z?n~eTlVhWr)O2(qs=cemXI{8=L14b~vFOk2x3OqzFquLWy%2&Ye%Rl^o z1b#1QB0c;LzdgY3eb^5FbojxdQo=QyY0Px?!*7`CR>U3W9AlHYd1o6!rS+eHzr(N; z(V%$Li2Hr;xMUfc#iPaYOgjWhFr?_dbpetbdG+p0HRR{v ze0$WlI`r1-1F`L{;w??Uf&&nyH8orjMf)WtnCZJgej}t{LrGp%zEejrI&WGohm`#H z_COY%W32a9z`sWeWHtGo>oN*e7&s&~?-lzzVD?WN(-qb6z$B!m-kRF+zy z?G~+?RQCs!!GBV|IJ;gGSJHTZw8(opBjy&+39R`m$ppmcD4J~f-d{!i|5zp zi}Rb@`&E6B|5}<&F|pXB>H8zO_9t|&$tx?{>+fW)%&{xBGs*Dt-Sb-OIV8`p`d*A0KC0dfgsJio34C^RR!|7U!NhO!c5w%bWF- z+x~DD0R^=DXSz1@hLAD@hD)_jR=+zT z`szS^)kvFNm(t(%wI4T@2Ppg8lE0v4#Ln&nKhyq(lMbbI++6M9x2WH&eXiXWO@eXZ z4z4l)d@J)pqK-Re^W%2YdO&fBk-0gL&SC(?iqYV~C z+hF1TinK70tjLFyovBtSONRZ&fOw@I-KQ)AynZv;s`SdA)64}!+vxNotE02f`iH@f zs76wNncl7B$0#}YP6;LijC+67!icqShko45V>PL2wD-8!6t#CiE&j;VH zjCF6ek+yfkO>84atcr;m0-*kj544Z7{Z?DHkdEdd*r^P)2^ou&wVH7&n6`*N!akQ; zym0$7HEk0HKWd+bts#V#vhwVqbe?)!v<%m!`U*?x{QxYdW2N5g{#GD2VX($elk(i4 zihF0nBG6`$tM`$vUH0PdCtlKMm2u}?$4WiAV<=-aeP4Z4Eba$vLy<_Ze$pNt3U%n@aWQuJx6U8#t6R|rCvZ|eNJJ?R@D@% z>JI(5h0`OXZtb?DNT}`a-r1{Ma6Dg79FX%7LCNoVP6Ie#_KGegpmG{yEZK{|U9eNn_ zl~nn9mTxGJjAw^Pv0%h<@$Z<^@p)(l)o{_1o4j_oH-Rh99jev*$+_3+XU8XbyKNh^ zBsZJ>0)ry|&4!tx$m*2doic5gjVH+XpzpRHum$IPvEDI}a*S{o)EPT|1#TZKF04M3 z62>{;ezGV2x2con>&kKG26zi<>mPU=0{2P1J4t;z_wNeWCK6))pE)1Oz0ZnA3U8vn zj-j7!jebLq0OzoKTKn^pnJu}uD#5lr_`@t0Gi4$EEXD`afg!)EKE?>Qz5gzY4+2(p zK2G4feQO(T>5h;sQ@_enCG#-? zSEApS(0)OugdScG7lIxZpxu%IfxJZ=pRF?f?Ym-975MMx-s`i~+DrRmg8z5Ktr^{( zO_#5>ev_rQ5P$g(zrW@%tzp`tt}WgE-~BZ){|oX4e9@XvtLW5tlos)$`Ahr1s+5O) zBO(Y0@JD)GzW@Q7mQM-4(0PF}$30K+{)DtVtm3bV@Dn@zMV0sT(o8kppPlSYW0+Ws zqulQ`!UzAF`@I71t{ktAcUvZH#aMC`c)W=FYa)A7+=PiFI!;b?n1{~a)9=O+8bslV z(!VJKA+VI{>(hLmoEMk&w>JUQUNZY=hhNTLWH4djtmC`rmMczkqxFQ`#UH^oqCh-~!E%RQ^pKt&(>e1p2zv4HQHYe-3RrCR2 z#5750emUQZF;>JI-lc32ak!u6HRG)~6H*_N8y&H^R>glKJ3VGQ_cqcDo7cG~tO`LK z3thotL}t<8{(quD?>#;;RPbZ{Mv6z`f~ms4s_=iq|Jg=;TqD zf3{X1FOz3!eUbsSN~aWJ47(Skrb*mJVTpczIlsuGaBo22KER+k=6!$>Y&JgiSV7zr z(ia(@+J-0Ze?WZd`VVQGaIiQ&^`Ns1*UIA=;`xv4x6J%9Um5%Y`b{8ADL`NIRiYW^ z&c2e`y(Hhq@OBMyo_Rc0FFyTvkI%jXK0YU!f9Bro2|xF*QCkXCsrwo6m}r0l&OFl>EhnB(2B&yJr`$qm({T zCO?wz(IvK0Uv*RC241{8i~GM-?GMB5By$t}a&-T1D4WDXy!7{n$kqrtfYuvuM+dzl zF~4GcH!7?7!g#KJ-$&*6f|8S3QMdR9+D(m*b(6CC5`Rh;AnQfi@XP*SQxO$+(BmfS zSw=bO@=x$w@@IuCeozAmky!3;ti6$kQjSN7vU9Bt700gCsfLTcZN+7yTI!*9Tl#`Y z3TUJn=ibLB->)UGMUfS}zs;&p99ECJM%8mpV8a(fK-F9;qV-9V``g~4Hjm&fGLAp0 z6+xkTv6VxZ>^u$Khr^2HxFI5*v9`59EC1QhYlav`+^<0#5w^sr8n>0jZfnD=5651i zs`xDJ$Sw3vm`Gm^^plz|&FduB7#B-WpnQGCousib^!fVrN^Hgadisd#cN-1H(xmYL z|BlTLz5dG>zr4RgZUX2&Rb3p<+Zf|&drz}l7~`tR*GL{PB>*tJe`b}0heV9mMH=`n zTI2ExNraD{)tYa+I?avdpW15vv$gyx$mfiHR>6P3-O=oc^Un~*mG2)(!*f*oow#`%A^`-Z(ge*=wxuBIIcIli>-3!75>yQ05k{VC_~;a!W=n_X{`{qm^1 zd{(FLZ&`f_Kk*nM?KSP69nt1&$g2C1$cxqI-t9zU-aoqq`@8?BDq>2EF?cin*>}(& zz@%6BXMd-8iv6>x{oPk8C+nZh?C<^-j)Q2w$vN;_R5Rc#U#>P-v9>!sJtek8lbkoLS${(U|+Yzd*l(hOvyt&GsCO&Bd z0)2`0cVBG3J9`-CBviyNPnt!l|$CQ6?ndO*& z@H=siy`UxVJ5#X| ze~&*chX(sUz@K*6yEV?VKkXrx?PmC2$_7Zqw*>wB|5^Xo zgO&cV#6Kdt4mLUob$8fJV|OKNJw#Ea&hxFb2icD#e?Vj_nebaoLXck>`(12$v-g_< zU&$8P{T4rje9>?9^SbDd%9s3{V7);aCXXx}QtzRE<>(Xixj>Pb#U1$3`*z6MVi4@h)*O};G_|NVM%#e@&iv5Y+KRCsQu0ZoW zZl=M;_GBgUvrHZ)_`g;DIq>mCls}%UnkC~?>tl(%DV54FFnE(n?)g_!JlK^ruSv)K zjN=UrsCQ{A;q2NtzzrO4S6aMNrF?T*ad8;)YXb^FmZZD+b?S6Pg@XnTe~l<@l1b#ld_7rW~yHw17eKg@;k z`Qk1o5sISpTPZShtPDU$2aQ%I0MB3;ejXFVjS z=?MDQu!G4f(fj_4sboM6H2;O~sL#m!Hw&YU<_O+Dk{5av&V$694(CL!pe`YcN-ZR^OcjuXf{Cnf~i+}g&O+JC~U&puW za)03OkNiDS)01043O_gN$J%fHp4w+G#F3}G6^Q<)rSEd-+PXLzZuPV-(6q+AijqTA z^QixD;XQn4o5W9HD+M%DXuZ*DJVhBGj=Pp6_dMC7=0jTv ze7$@!KR)-N^A%mN0{lu);ac_~`k{X92U}*vE?i_Np#5mmMStGm+wb1P3qIhT8ASIg z8}S$SW9!v8E5k&bX%DI#+~|f*?ELM^HFRsQSkrLJd2`&U6kD3xNG&CI!cLk?`{c}G z%X`mU?IxVrUaCFwTeUR{-c5;qH_a;b{`8!lJAB~El>~%|!fH7I6I`@CIPAlbpGsJB z+odGGo!8}s*3Vi>r&2y-bv~|P7JZ#h@_Z@1k<2X4$YWKmAZta#EhFw#YR;ck-)R*m z626NvU9Q#oCeIiiZruTJ@mfJpJ7``sk20t^>WLi_3z%E_1_r|R>yg-Uzf>K z&rjgGAwF8?gISC;b>GLxLVyh$A(_-3yKh3j@6@}viIA|(iG{KkUW1*K-Cq;r6C{NE z-Cg@v%I2@EKbi6m8fbgmns^^dg+8YF5InmX0rWDr*Bv_!sM+pA?EUrb%l{vHZvtO; zQT6{PErlRpQm_y}A&5)agMb7ol2WeTN~;wO7NNMH1wjR+!9HN25DK}yM5=<+N0IvY zC`C}CvP2O`DK-HYBA`S;5)fhHtu}&|$kzY+b7sEFU9wbg`T2kPBHZtHX1=qWIdir- zbB1oYH~6&0zQ4flyEYze2k>&ge-UdQhBfzDd~@5jIZ8?H6^5{kcN?xCY28!bFfGHH z4+c;CT#xbnHdoMf0^RDfxg-~^jV|*9GxWznR zp--R$9Urm%EP4@$RPp&R%AZhLes8}Ni_4ey=P4}UqwQzL>(k3~BX-Kf@AqEn4d*P^ zqV?R!SXul6q5+a;eM|Rk|JH9numW0#-Ez&0UjdEbyj#E*JLI;t?JiPzvc826kR#I% zgvtEbOffm^`Dy7~tUC4ZEnhjH*F3g}0(J>wZuAAZ+#Kzhd1z+i_y>NxCG({(46n=Q zE1p{+8_HDPce+HrE3WS#S=L9bk2(aeny9Lx@yGt+{@#|A2nd~kqYII%i|=^O3`&+c zQ|`OQVp!;(H(y>)*{?ZBqd`MYh^M)yPq5guT^8M^MRNwymjZ(QfucMBgn_<#vh6?ZEVz2w0=s9^h@V zRP^zT=;OO=%KS)v`vx0HH+kLG7?nsEYVFpzZdb`%y$yruXEc(9{0*AEewEtVI-{*B zfC9t;){aWbtyS(mdgR!(X#J7)j5KCJv)%i7_1E>y4-#Yr`v=QB%yVUaS0O*K7jsce zW>9djQNcwdUj~|N{{1BFO_G`7*bZOx3bC3dDm47YuHkRa3p_RTdYL^{zd=gREP&L!RZ4InaLnB95vtk=PApsgty8 ztRz`dW&73VhH@$WETW|`|4#cy^<+lqEkF|8fkfzx6I)wq3o*g-$8`DFo&jxM^Y|3M zAG+>Hqvd>H{VC;NLUQM`sfUd|K3RXi}nhV`Phu_YqGg*?6^m+ zLim!1egs=22JG|Gu>UrSe9J|J7!Xuc$sK%lP(S zjR!f}?l<4r?r1_>@k5TCCldTC9v|oL%r@D`_rvZ%i;9Whl+cGD@0)*u6UP~q-U+b{@u}Ukn7hft~7GHL&7>}fzFx{ks zVFvHS{)eoHoDuxjE|91jbmP|FnB0LhG2p)Fp9h2gTEA6^swK7Ih`p^GqwpiRN@c;0 zoSK9m)?Rc?)B~Ry`LFFKqUgRt@$Xj46)iZgb=dbBM~{1CFX}3HUOP=iV&}E>h?$Y| zS|@63iSybL3YR#qNna>+URwxl@xf*W!hJeHt&d%1((-x0zX(5m?MFBUe*C@om)57& z!sN>_(DvWQ*B9)(ne>GPzOP_dvA*zOrOTRW=YJ-oFO1%wh~B+e`M#l_`HbZIv-A?M zv*-1eVOS>__Vt!0tOF}2Cf_d#V#}rajph57ryBX78W}~tfBb=@GlxgzV)=fha(jSi zW%>Tv)W^@i&PLK*S-yXVN{%bv4@p8XSF~8Z|Hgg#(B%7qa=m>2Ls0{}Zvp#GB;-r} zFA?%n6wdn}rs!M6{o`@+|EcnRUevFIKc@O;{O3J!nG`(~$%pPtK;ED4C$?DLKbb_e zJD$8>_`Rm4$L%2Bx-yQEhBu4U>?tGelu&mi`Tpc7e7Tb1QE(7wsLk&NfH zsaQh)y2lWt?nHG<^ZWSw7b7qKpS-{ox}D1LadYL@B6(m`dz!5e@E80p zTmSL;A-^Hg|B>0t@W0~vE$we=y=->*W3Ct%9-7}%S#aGDG#E6tw<}Ox(+2E1)xQ@J!*&bWj}dMb$jNo*$)14nN^6r ztHtPeU&Z?%)eX8Ulpvv0FRT3v;sXid@UPd?a;s+J#>~cQi$_QJtpa>if~>rrx%TrO zMX6)QC~`YF6^S~rPfP1wG91&BVf!?n{>QiX;Gd1# zrQ0hi@9ypfq3KxgCsDzK2N=9d;yG|<9Cy0&MWf->fa|}-_MGNm2_*HIJIv8FT(NNd zZMIxE5O24Zm(8Ezd!f=qqP}m>&KEa;Ug%@!MrHxVd|~(ug2(ZH-sc+z$z`J)5sz~- zeiZxJcHVA&wlX+->xZ|RCZmh^e<^(^d5`S#(`lg3)-;FqG1s!7uuU`Mn^C8{$N!+C zOWx1-VeS>m=GM5EiM67hwzsg-Gu_Miv6%5?@E8vA4=XA0r_x4DseBso4~8X!=mIVI za6fKdO|k0DBQ4XPD3Diy9{1C` zRXEe7^kM(pXMPB}gS+;kAE`>)HepL}#V%I1n{T`0@&+O3?UH_q=dHNcpirhvS?{k} zBxSwd{h8`bS?@Asz26P0JyZO9+`+1QMy5MHX*N?Wyq%tU?Y!S@-$Mz1w5;7W7}mJ~ zDlqMQ%1}QdT7j;{Z5J+-LT-K``CA1C_W_+v(T-~Cj!cJI5Ns-1tA9=fy3x))Ebo!**F9ybF0vZoA|Y~HQ;oh-n8?yI|Q+O)Bc2!^;h zWUKKDx#~>KD;2$d^LyK=?-b9JcCGEsr)p1H<32_kjBMX-R$6w=-;N}AyVkEvrqqdR zl-`%!O%ELyu~UhQK(TI!DDGu$v$r{r-{$f>%67W}V zRsBsWdCos`b0g0^?)NI6pWAD@TV^mb4Bp?m=!;rBAnn2(X|>pX1YcgqmqI~x@@m!0 z_T1~OZ?ahRxO0)`)GM~X2EkBvnhNZWC%rj6)tmF}d*2JycbVm7v}x#0wjS27%Z9K} z!xGfJZ!6r7hShOx+g{ZqSV0}H{S&_(w>BH-TAt8$?ZsB{G9@j)BCCuG?i4i$Tq2vl zbuo!<*?*^al!MKx}W_;i3#{W zSiisWV*?osgz~W2v$^I+d|<#WqN1TA4BvfLZJW-v0S4!~Kq(_@i&gS%0LvD_#3;+4 zzS)u4ju!TyE$qvwQwtcT&YswaE$lCY4$;Ey&F--#yY)Tpl@0LtvsK5vhItHQV(mVr zZ@$8@hp64htld{uX!kW0+I{m%gBy5m{wMuzG9UW&&lGqNouxRQ2E8`|DzmqG$D)Lz zm(8zx(8y?!JQVD&#*5u8<@u33z_hV<#IPRtW6~F1d-duu&bk)D%*X4A`WqxWnK<#H z_QSsYbZB@oh%xNW*qQY$H6s=|%Ewzt-YtJ*nh zYY%FJ1wG-eN4ia5*%@@D&cZLrG)ljXs2x4p(|$#Y^hYP*^j_%rgkLxPZiVWimn#0) zRDCAqe%5$cd-GztTI7FIw7yOkEJwGen!HdspOv2W2NP0Nws)rO!;yZ& zGW|tZ*||(~pNzYWq+(x?pIRY__dRY<&nVeuf-OHkGQuhtaVPjf>HW>p_BoLOqXLxJ z3SNo&WI`u&y)IIv9@cDquzORY*M}yLXH2h6fxj8Ol z^di!~>Zt^D3>qO2dmmE^#^EP5D6&^2K_VXzEYfGATS1E9)37=8t^$38#+!dhh@ZPq zXEMy(F%kcggkGEeCR6N!pucr71pV8cJ({zpxUalQBZ9-k@uSu&C30~H{t;>TMfQdC zd<*udk!gCL%*O=iZ&Ce)-A0?=VdRa-SI6Mv{j2;MNbe^`^C_97m-&RWv@ox8(W!OL zKzcRm*9XPVrT&1G3wcK9L`KWzej`DPLmoo?=|Nyj7;3OjCF3i^w)%Md3I5YEc<)2- zC2PQ$Af}d`ThFt157QcWxoO}>b+Vl{+?`t zzEk!@>`<9g1f7qsmcZPo#doqEbB&h#9-b2>>9|ZuCLYmvp7mrsGa6E9y%fVoy`%oG zy-jtZH}G-snXF+;Q+K|@%8`43b^eaA;MK4>>%X`^>G^u$7(vV?=lkE|Q4?nI{(Rc* zexwudN77`_?Xds#fW~3#CYJ9-`@j{(#z0f_qQ(E4;_1c55xBCaFBxvUO#pYd>op=4 zo9Dl?IrJidPnfHxQRynrm9x3}r=6cWNl4@8Vu$bYsQLNfLz_Rus!4HxpDqLF=yP+VGL427JZ* zUGqQPsEG!IsCRR_S1J)thpSp=yXqY8(mCJkk9~b7uY4>*1Md17J3f&=q)=nWzCN@S zKcwGbMKUg&x4MGY0*-7bR$hfNI`iS>73~9br@@wr!9ljk);OM4$&N&{|J+DlNrllx^Qd_ZgjOb zt?_UxqsP9#ff$Rt*o82>%Z#f@#(~SN-NLA5rT$l<=YVkP7wI{_JO4MoFD|}`{JXtq z@7yjt2Ycq#rc8-D6vdP7|B^KJ@nxU{em?{^Ai9}%)i>?g?S#qJTsVhJn4@L z2>;ahCR41r(dZ}g?bz|2Pw*WslHVeHL!LMJcq`9WDC70%@z%T7@4>5b`CxQ>VhIJ5 zH2Hv8o-wO#(O#O(2fWDQ%qk5F@?G;S@VxU!b!z9IXV=P z?<6GJWczr(qVR<{)6x$|=a+bRD|I{ZIz1k1j~4&r z6ds9xGG%tPy*62n1w5G>=h*9RdiC*7097y5ATqNLH7ECob_?F8Y+HpBjE@X#M&WP3 zK0e=?9NqJAN8cC*yCIK^cu|rHBFl$x_n#7<<3V9TR4*V|7U(Xzn zb`)%m8$aHOAOEa6$*Ojafw?vi8gRLz)}+|3ckE#!v>Aa0e~!_58`&>`Zd9v>)M zzP?za3AqdWG?JHm1I6+j(9^%Ig8o)S#g#02h=wUi{cbm{a^v&}hVS$*I2ePjLb}*KrE|a|?z2V`r2XIXbg7})!+d)_zUIW*tBcl{#4q<$B%&4h z8wp-E<+ydc8W6bJ+ghJ?*IfX?l=5`1Q)dUnwI9%E}}oXk|-ti zpucFYd&Z70t8O&8>{B9(eye9+eQuY--&2 zF2aY%U;85(l5`9|tkmv(vOXxUH6%K%zeHZHM8A@4>J~7-9 ze*yCcX{LK!G~ElI;CI6DXN&yzmv{%OK8Dz*I?ChE8n4!x2GA_@V*h=jEf9MaYkK6r zuk*sx#j@&gd#LVm|9v~J8~g9Si4P)4x{v!{4eyfRv)Ws7qLs$AM+dLR`TZ)v2EJRkCphB-~SYzm+`Nn^>&>g!02^9#%S|fQop~y zB_Q%k5r0;CtZ&=KGdh2>^I}Q-S=nbIn&OQ#5k9g85_zRUebB87pAp<;B^-8V^9)|# zSN}Srr3+Je@3m*6t238Ou0jn?>x0Ir;w3pTeaO#c(!Zklm^l5hwI0QfF_KzD4?Mnj z`H#8s#3PL_{`>0`*TOQ>{4b4fqsC(dwW9hO8B;%tdr*7UQ>JNA!BTc-e_e}^$$-(L zKFil&E}o0+nN3TVY*L7*(=)?+)ZR3AQ})1KN)8w9r>txQjg|EEG32B4eAAa<`XU^F z-j>rN;lp(AdBDP#j;`*htd~RTg^nhN6dRXP`a=WX(MCDFt)!399Pp8-Cb30-)*k)C zPwbedjaR3~TfrU>-M_jYT`RtCl7!TKlj=E>X*6WC`K)t2ib-H|Zu95cYo>bv9Ecg| zc)l)pMO6LJD>w4RxcnBeXK!PlKs?`Hs*0Gnm8_R&KVd#S01LE#V48%x><4N@MmFO4 zs=>^^E1xQk2O|7x3S$|J#&RD@zeh60Gb1y6c8x~$D(t-a zy^%hW>rqi^>;&&qo6Ajop40V%RT7<>D%wLE;>jJ&KK0ZVHbWKhx1#>1D*cl85#dI= zKkc+ovEgJ2-|FHn1*`LCZxReRzjw37^rGVVZi%m5#HA+?&)3jwK$7zx#aT5UKcWxO zLP{8DOz+frPd_Wr>lb71S}!2{Q|(E>)e-Y)kB!)M(y^Ht(flUPa;~4g==WmSdSx?%d8L+m}oG15v^;?b^u>Q!S&#~9r z^y=+dc1uBtJ!_M)ZIu<{K3ij}?;m-;)tK>nN3pMt*Z*j7sm($cvP4u=ckr~8SSvs zq+~_&8PhvgH~=V@@Rv&arSC%jiflzjye^`l*#6v*%}@F2kSysM10vLt!FYcFL&oD< zD$?qDeUO!5!@oz4OVPVzF!F_4+r8T=+d8|~8g8PR;%=w+rNljFR+ZI^ zc&s6>kGwu7wC~BJ$93%l-9>s6Cs@eAQ zNjg7dU7}w|ku>ssjzu!!^RI=x=)N?Ix9ubBs@N7P)-ji(P2o7t>|DRQjBkt(_PP7- z0W6|!Khc9(qJqxBBIwPv+(2fZ`*u|7>w3@;p*udD7Pl(MW0m4Tl&t5X`LX?V#yUa! zymr&w>r3qY6RH0`!OQ4kV!o(=uhicd#diZ|ygWIP`Yqn_gz9hd`l^-n`j*arwfGZY zO>=YWX6Nn!uU3Oso!}KXm03L}|1p?Gy&RKfS957MmMsn;$_4G^v-24SR>1A^EEM^PGZ*-?&!U#Omj5+GSr(Q1v>vnwzIbxNpGx63-g|oe=YMMr7q8#q^$4(R zeF7bdrKdNRrz}5N@0(wqZ;SZTSnskQU$DLt5Yw|&Oe2oqt*ZdF`?-Wpvl0)2Xo{P# z-YfzXl-vM^<2W3tuQLnWviF;$b;YUr>F|eW=O_mOBMG3Os6Yy!@CP;Uv*HH47}g%Q z0S@^#e8%lvq9x1D^v&pqBF*T{{a!g1OgoCx@UGBILCvfyX@>P!<@Si10cAromNDO& z;lygLr5$Wp>MrrMcO`?+eVZD@dez=rQaiqORc`GK>X85iiw?D0#xpXHDqwl8WhJ$* zaC`aMyOY`jCH}CLWdG>!IXT`AS?k}TpWMG z(I6?AVPe`a6T_;f&)sSx;S4fsQJS&Qk6>T73VN-Ajb>%{6(E@~jCb=P;`x^NN>mm0 z4|Ov_(@uK2(pd()_Nww`u(SD{wlrD{Gj^jl6X%go-8z3`=8x5_JMl%gtG!QS;%ojZ>D$q9-}+L0+s*e)N$T4G zL$|)|<@?s{UKN_Dz1W||qBprrJB_uw@3GK%5!q>XzqFTS(>?50GhRKqKatE7Od0wt z-3Lai-L{|bT||jd#|h}GBZc{<0EKrfz^{3lPYZ*nz1$;$m=&Rx1FRQydRXTP4c&3; zFaz+=p0nDZtptro=f`bC3K3QCUAT)b3>`=Jcvq+yj}MI`EYE;IH|oi+mNWR8?oTQR zhpLBmusXD6YcG1c%@Vf$?q-0nf{IqSIw1?nn7tfiFUy*!jDdFn5k0y&BpXB?@et{9 zr}=_-hcS0{1Y9RbgikBJqcH~1%-r-V2AWkV#ItEXR@RO73U_vg*gGdH198gVIL}HB zaH#t($f4=hlL|8#tjZW;2w@doM*F(EVncOMA`7pk#C$%_UBN9_>V2>KJ@pU0o-tE~ zjth{zu8+ig=Kf{fi?%9M4JqD%LAcAELX|^X>e~dqr`qd{`my{JT;)Qjxd>?9?Iypb zdUf@p;|wP_Bp!Im9-q+Edj9hDUkeW0`p~vyW!0j+8P-Y}q5V`Y_D$JOP7rtimjhee zg?FhPql-(ST}y=`r_s7~2HLivx^SR@ehPZNCGL_U(K~X`rjF7EtO95JA={G*+#wMY zY0)Gj(pev^!`=7Zw747Sou^+*sR;Uon6_jo{C#P*W6GCTq22k=3iOhku+(d=JbSE@>~SGzA>AJD#aaMOK!2d`Sv zji5@o?%BDw)Y&v`q54yhU&_}3@(8de9uL?@mAAz2rUQ2LA$Xoe(_yt8^WCd>@>3qB+{jv7 z=Wd}xQ7RAKUX^3_qVxc~^m+AfK7H$=kKHjp?pDif-DH?#(eDn_O(Ho}#WcO!zw`n@ z2P5uvXOUnS{9z@z%Y8n>6|hBLR=HJ5(>Y@Vm*p9FKAr-kd)oIkj;`DH_5Kt19zi4+ z8@(1&FHAK|ac()a6xt;hq(WoOH*Nmta{Gkh8;#%)lEARorK;4PkM(89E#}DKnz8T$rka99BRUui#&J!`d1bGOk?XS2fnr%C{let~1-&N1oD#fC9 z$g7F0A`+JA2IG@C3WM;LwX&256le`yny;}B-XTi>sqa@0g?1a zsf4zAxnFBzrmuR@R4Z_)3gDBu=mvhhHv&T(bmtr=^{7}s@j*aqg1g{F^wq;Z_DAs; z1+nR#o!=6aJ(KqO4SkkTlowC~Tw3j4giC{lOY$c(T+m%2gUTv~J5iSjy-BP**Qr8?U(u;L8)fgCK&Y&OR6yU*5$x zeu1D^$nqV z`oS7d+-W=S>c=lZf86m~`BCf-rTYOT{-~AL-z%83QR?&l;Kl28Pd{ga?JdwR4uQzw z+~Q$_WXn1A;P>=nePwzA&jq4@!|o1MkoYpL_4W0)w}8}{{^k6X(%N|aczZ!{f5w1E z$$WWgB7 zy+-YsQ*n>0SKUMnDUJ>HYD##YqJFodg2fca2HTTtBO+6V?g->nw90zqV}n6RyRsn| z*cI}iKzX+)dv+pz2fi0f3f2)&QF`^nLg8$FB(QJL2yt^pi3GO6Fw-As`tm(5Y&sZK zygS>m1+3g`C+gw z>}uj12~njlP*X1pl|M0*749rc^Us&qbB{YxzflkrTpD3yf0&MXRD}$a73j-JvQA7HHr3rSNaRdE2OMKfZ{yns0?9Zr{|5>WHao zYw02&8RVgGpC{{2XMk1%mu{?oz4%fK$GhDnB1cd@3#2HCXh+;_jaHettJA$v?zbJf zm1;n7(%!=>QdPf%JimY856`@hdVHKT?qmC|SfJ<|@Jm%@48ye;AD2(_0ngi@!~$ zK%bXaAY2oVpZ3N%5`CliX}2jxV@@gxvr-g4?JrQ5(c-5qzB?%2iv^OsMO;KeCPusm z^-X#Fw0BcyY5cSk=O$D!il6q-y{rU_pY}bOkS5;lV`{fNe%eEKmACsCFe;7P_QKl? zZcqr;O-F0LTg!*myztpWFNvRa6BsbT_-W^gINIFD`c076Z2sLX{s3js{z!VgZxblE zU+QJ}mFJ4!>HD89@AWecx$Hi)1rhQmF|Y{X0jp|c zO-A>j+4%~^Mu04b^Lh+Rd| z;@8d5ks42AS!SJHOw6R>*FC$Pdct`w+f<5V6yb6t7{~GJ8dVoEiHg5wt%*qR6O&We zD1E{Wj;N}7+JUmla84Co>go3@J*qK|U-z)S2sPe&M^q!9j~>77Tzw+*)%0}JAC8-j znzSyA8NcoVzKI0%)@_WFrQ_FqkR-|MAVpwmXYzrG?6n2vM0Rk2Y1H_2zrezzBKmJ` zmj!;oxQ~1(SltjZUv&Js8825iWdkUsf5RZ&i0A@sj<~bpb(yGVDSNFKp#Wa67(&L@ z2s3Pm3YEpu8F1ewsd#Pv$O`$j*{5enS6G`%Y0><55_%cz1I*kg@z2<)u^z|%!t0e1 znGBBh^-Y96mC)Nd7NTIm{kAZ`%JA~}*GbbF1)inx&Mwp9^o$`bf6>1N+Jj!%{di12 z&ume~w{Hah4D1#WzlqBur>P%S-u!337vDPC{i^#5Mw<4x@UGv@R3CByYT*u?pIjTT#?PrRu0_7cbs ze(fgyWkvlt#;=bG^v|znYaf*L%d{N-AH2`TJlgkW;zE5075MK<_Aud+qC$?6U{OIG0R*B<}|N^M)9@V&M~#^%~)q z=(lJ$w3uIQ$J}--$j$>URKL@sZ7DO3S%f$7TfbrX7unOJ`eJ(WpK0Is^rG^8%FWET zXNS^5C(A~Z2pjST_R}Hj=Wh}1MVs-l5x3~`}KMzujN4kn-5Q05L4s# z^IM5NkE6eiOW()&KAGQOFL;mez(>Av=f=;C&Z2EwdXrmAIxz6u7~l=(S{{pB${+ZJ zBy(`%-G`;e8twNK`J;0mk@RPGEnpGQZt?aK?~dN=<@0$q!hlxg*~(0Z#_L#eejg>Ojo^3 z63YM*`C|9ii+Jv7TdI8i#RTdlSs&4SFvrMFOyy3vTmD;|&pc0;y8#0D{aKxX2mGeP z<6F4TtrEVC!=J{bx25>T2lep+ifjWHe%|__zP;y5F-a}fS5#IT0Qp1q{SHL&0F?`5 zc=DGRnkU1_a*6#10&NWP2=S1;%p2%uEQ`nTilnQh!i>QG8xnc~a!Y)Xqt6-IM>K~q zEGTAkxAj?KFOKahOCNY)Q@&mv_&2fPm#a5gBNvE6f3CT(oFCctVZBJCnZeY)udmVX z#&ttP`Y@`tPmls&z?KlfWD$433R3>XyY z8x{HC$sDN^RMXTn(udOcz3Y{}PdiXPVg9z%5BW{a7_!&2VDTP-~)o;^38GGltZDGt)}*& z3)z{DwbKgx@=F2cWAnp0@d$b`)_FVh#;p^qI-77L&-nm_;`O8YC~q3hh@GGE zYD~#=6v;Ebebujl?KwJpeP2hB4=Ty)LH~{937sbDw`TC)@K>;Qnc~G*g3FJ;8vJ%- z-__N%%P!~F`#MfzN>DoF@R@wk2VnZ#g;$vpVjCE&3ek(JeNxAgc5~nA4zGvo{Q=39 z=DCgB(eAFf+&=A?c9_qYFH>K~jb{o8eiGHO%2iD^5kI;r?M7d$WtH3ME8+VZ|NV6T zy<96?K74Nn5VQ#Qw!-pH&E^kTaveR%Py5rg8rFdO=>C(dhJIk6$)Gh2582ivh|9Bf zf&IgWqK9`x4~It&sByl`4&i}esyFV;{cOnAr4QLN4!0-xM2*9}!#~@YXZZr{?r{Gw z=zh#7HUf0c9@MC#UnisRGLCa=9<>xCU7fuzKA_tqt0C5JAQ1DJXlUb-)#g9^R~F)G zqbffF^r+sri$7g8v{br|2-fS)7gYr^+g<(*`b~`XMJHRvc2UOS8ld+nGTrt2c(QlY z#>`)@)BOUS^#}5|FaW@t*^EsYpqBl&x00UI_|`?D($^eI?3&HU$l}< z?tOb}lDLJk8$GyxQ|q?wF3zRs(4w6UYR~w)dgWv-V$z>I`7UI$+KX0Ep}Ux(y2{tz zX{oN(UUY$4(r^zAE$m7QI#zPJrS1_@r>b2Y*?_ZrOH4bD->jVF`*?BtQE@>XhDm8R zPz*t54BBuPC_qttlz~3?ec?DKDUvgeUscNP0z5NGpL3J7tWq>?zMt4`cNINI(HH5f za#Vr99Pv>w*X;y$(5gDPuO1`yGtxH_eh-bw)(C+A_5P|w91@bIqB&}Qf3~fwhUt&b zS*7ePCGt*keKFK5;n&Szm&l1WzeG-)-wOjISbuJ$X0!0%9S^{ds}mCeWCG(4J}sCw z$~&H{>+Fp)t-zH5QKH)&`Z!ptB`$l= z;5Bq^#65GaI!AlOxW0u)%%YnOO89T2Z;2_4%5N*t^ECe+BOj~f^XC9)lLAusQ_4Sr z{GN&z4WHxaScFqZFD$cU|Ei+AF$RB)^aJRRgh>+thTSKV2Eu-UHpmR0%pc3&e``XP z9l^@xj3H!u>9e-4P-pAb2jmv#m}Na$DLLrZ&Zz#mY(&HQAT_@yk= zrScWr7VVQVJsA;F%3^?%wekus>CU!2TV30BBrQ?cCx1rCFz1Ue6VxF=D%g5oCs=}`9b)O+w{jwC}2p6l~4$siEj_+`nlcG~tk5lfD z2maUaIUBCXUdQ)C>(wuokS=G+U$vMX%sy;j(KPC9TRS2oKZ=pfIqcci4V=ZgDP4HM zirI%f97-}J1MdFUO|F`A*i%-rEh$+L53~A1zptmvXU1FDt363-5-NwHI~U z{P32`tb$Uka#JZnYx11v;F!=S7i%4wQgMns(vgZwvio3fY@Ue@F>|4Ya7e~}w$slK zH*NvD*n^=GiDesV7X%7t=wMfP(JW7yOxy33JM7c$Z=W&(ke_>J?(Vibs&g%Oiu2@7 z?5(%X%S6DahTgywC4PJQuzQkb9c;Tq(_ehUtCG)DvP7$^UL#VJ*fY$2)8Y{8n%i49 zWlx3*W%txTkU8N2HPUbsSN~W#j^%+A|JWCtau0lg4?O=^ug6mUk)}7tXc_`ViTFz@ zf2{pKsARD=5`7=!(^2!&_NockpP*08&^S+SMk$}(PuSe@qGwGsFeq-9_51xSLYUWA zWQ6p9^z!>!cq_#8EdrWP5AbV(*2VKdef4pNBl>u()s+~tE~1X0pO?w=mA*H7SjreS z`uFirOtsfhHSJ-9?L2h<^rQuT2nNN$Bs!t6tjZ2czPn~#!3+Tvz`<syz^8^Tefd-z0#i=)*@o=8um!<86^D4`efc}t6(2XH8~7wHEne= z_%811TRDe=cPw<=q1+9%K2XNCk>sNbO+>{Cd{in-WIu9-`fKnTOyczvb^?&g))^ z7RApB{fG*^&3eS~wIjN|3N1KS7tE?VU2tNTEn z1h;hfj>|3UVr9v5`ggmhffva?CHM>O6xnC>&dAdC?*`I_Z92SuEV-4xoVgMQTU1OR zrQeQd7@`3kS2aR-HKV@}IL$3`!2RAh6%whBFV^XK(>+)v6kqI4a;t_uV>sn#YDd zW#6*G_q~zIf^h5Oi?#FGPEWc*a_vov=ervz?9$ zN$a?^&icE~?$ZD>eS))iGZL4-`3I9&^jJG3aKIJRzk)tUO6haG1rBFlVgRt-TjKYX z*r~+OqQwi+%I&yS$A-i>cBd1HKh~O#Kemc)tqO(Q$E*Y`t)xZPk6N_P-9gHkMvCAS zCGMugH)kP@6z?Zf$hq3xe1ic|37rAjd|_}nkuNCQ2|LsjYE6b5#WSL&UU%86D%-z6 z2^irqJ5j8RKY9E~`yV`o{Wr3A+2%z;ADi2kY^uE}vk6jEasQ#nJ_&I_jx#9?rQv5l z()&mbx<_O!?GULOu!}kGa0C7vhPO2q`8U^joTvW}#<9a=e1`lrS_|N_F?_L_JpspZ z;=1RN|BMB-3?rG=-t=d;vjC-;F*(da-^L<9`F_$iLWweXCH?sq$Qx5k2+jq3^cM=r}}F}i~T!G=!xdM-gOlOI85Y4ao75qLJglZH@)W1}Rzp zhY0lfCKkm807_{e!XbY}6Z!6AIFw5;TxLYZ$BGb9y|GP;bWZLmJK39C;Hx|%RCy&; z`U*Llm+R00pKSgL`=P;WO@p9LsRr4+X%`y!2dvI)hd-y4%djxvA2YVlFvRD0dAq&% z=rdxvGwgBE5_;ZCg)%f{LnMN=7*3&o?|?XTMf<%s?rK70ms@w*3!8c}ig{Qybe>12 zZrwqfU$8RK9Y)lthv-zKJA9gw07Gqgp|^MFY_$kmlj2pyy|JFYKEw-4BN_-qLGn8c ziGlRl%QAZjaVbcfVUM*J-K!7H*0RiqRygjrWtAs{KJ-wC3GsoCii6jydDmjkd^)B^ zfbr^xx|2;KIOx6l*-k${{3)GxwY$U`fj}|TMo)rLV4zVe8#Xe&kBMgU^62SmzA8WW zp`aE#lu`>gLSt${-;gv`D}R&$2M7?n(I9WBU#7}zhv~R(1^r;~isC5b^*a_JZ;|D} zaX(R?=D6kSeOK)ZfMxHR;Ql~ChtMehlzxp)qz#O={PL3{@FOWj6HtQm3iYJ}OCV)M{VUJ87vxzE(j+ z>*RtvH8aLWNj}Mv!IEQkltuCAc)u^9pLz9W41RFB<#V3R%9P{RHs#-YeyJv88+4v3 zQh~Qq{5Oy{3ZfbfrxOIL%zrEMXLOeQ%o^SOx>s*@&B)|Lzk+|N@nJYMWh6)9-~V}m zqB1^*@+!;Uq0V^<$am;OC7%R+D2AWKr?|QNg9`S&;{J%Azc_zL>#w^-@MpcQjprc& zXC!}{KHWO_WbM?@xt0iJdbwnWo*$ z_ADdBfcv2QXcWNi?FtRMa^mGp1prpQ+H*Zvso%qwysJ#+iMvq0mnnaE~ z-73#lJo_hnCG103eldK{QD&b1wh4sQ#siR(^}6}?xduiH)?)kd_Bo@;TwpudpFe-2 zcZfkRE2FP3P5k{j+V}LQ0>AQk3BB?BOI=P@WPVl+qJ)Di>9!%~@BO_RW4G7-Ae=qO z$B?Fd{B((^YCgFKMW5vOJUaQ6MhLIZl+e41{A-N;7TN`_t!ev77_ZDGO>U(mic#>v zJ*y+yCF?aBxGo~f%^k+PHKx5Lb)Iu}?zuU+53i&*oy>HX8RGH_I!)4BLpQ<#+|n3k zkK1jv#K#`@I(|b~V>@pweipKRqF;nE0rZT&i6jpA__vg~I+VG_mtnTnxnn|^$)Sl| z!>{=vo?*ld1rtkG+_Pgt&QeV@9Ok~~LrU`HK>EGf|rUIb8pyeZKoG zIgVR=h;D_`u94_xga(+xmOS9z_R&q7nDwfeL_{_^`=>d%N9W}JrU~x~fsA|IV~ebU zZug)b+U_LsLQLTy44t_aZwdWTRPOtFAYz*9ds*3hm%_XBJq6E7{IHZ>jrX3me=J!6 z*s;j_%}YEUSWuFq2DOpH9_p7D$ao2ZmBr6e6;JqA?-HzL`}?GqXZ752=}rB@usF zA64!bCq_e&!9fFT@Meh`-^}}cGpFh&L`UA=Hv@?A(rYQ$YMUQfdq9ZH5yPA1e&8#kI1|v_En;bXO6*prUhg&nL=*S=O zwWp#ZKk?}EHi!Y@7e5#oul&Bc4E@;-Z_e^orCxWcg1&moOs_lFzjU)Ob?m&`;urUg z7Qa|_4s_j2Us?R(J{l^~_9A&m@^2QjgxM_Viv5+eI-T40Ow-f7zmmdhn%B|cmUrfR zwZxEAwtM&jWMp|QAq(@-d!h{UT3SP<+qk87^^tkVxi?yYCilZBlZ_$tE5a)dQE~v+ zy2s~;pY5KmVd>WHzozx&=WI*lR@x|WJ_^o8JCil4v(eqhtCvmg+Z0Nijcy33Us0|2 zyoh!+pP`b(50FNGGB2)s3-37~2||`KdB)1wXkC%B(V%+^P%6BZGQB?X{-8TpDX%tX zqwQ=&P}x#{qpZvXvas(5aMJ!FSx({nnofAqR~29V3Lb=LUBf>2PCv zo9;fKoVK-%`eKK2YzmYNMi@-$X^J+UXKbQM& zM#WE4aW7-V#`g%ngFI*al=2{Pl{)hw% zY1Dy@INtGab?>yi?sh^c$&IV-SiSeSCjH9(8Tnl$EqeU}05LZ~LC|K$TaY?DUmA9Y z>)EV`Y)#(bwowNpQhNs_$xn&BY0#($N>y~f>mMs1Uc`4 zHk72EM5<=d2vrQf1Ru?xiHg4Qo1}lsE#fqUKj-_W+KT&^o_}}UQND@t`7!*E{#K(R z(SCdhPL;}wW`BBMX4wbh+Mj0e&EIK%8Ux8k$x86GR^f{RzP=&G*T4NW zPW?Ek>5KL{XF&Urb( zzsQvsX8^9rI)?=7(|$^FU-J1~YN#Kq(?bnCqS2`}R$}V{wRg)m*F3Om)M5)Qrflol z-57acQp7*l52@ESZgk;g#{y{WfLl6MX#?);O_NM%ymgS7gZA_)UG!*!6;L;L*?#*7 zvg|Kwmsje_ek8)-6hw&EY{!kN!o5{RPqsEb%A@Uht#%hERi~}1Xphrt7u=~%iN_;5 z$V*LmkI`#`(_uU$_TfhQKIn<3$r|to;Hh&D5x;l}%p^e|!`rX)KJoFtpQZ185Z8Dy zM(xMENj^w)Z?3`wPRdsIru~f@yc0A^KCDQV39+MB{W7+|xHY(y0`9Q)zE*GLCYRFn z?;b=}*Ag0q9#_)8isS|N&$358DW!jN?UBFLNB?J!v|WvupTkc;rXX&V+9S7+boPyl zk;LtzQhY%MeJSn(t@At&|BwH(NB+KuzgMb_R=~cf&aMfn7oXx40TS5MU zjG7X+%Iz1%&ptK9h92z)3jXQ!S`5!{=6}yl^#2|iIu$aZ#(vw@*5TtbY|k3i0W8ii zRH^QbdJPax>sJ-^Nv}TsmNCvgY~9%=gf~ikj7pa>uzGNA6B3iQP1KR<7O#eR*!G$q3uo?*CP40T;53V*ZeoiA3 zSdppq{gj_Z)|D1yQrU*$VJEV}_$MH5M(Z8qgG@0g^uBUD z(wBc)U}p~Ec%&yP#jo+SydA@9H2g}_8xPxm1pPnhTlCHwRQA-Ii3Pk(4?gW3ejddF zO6fz&KDj`MI_$PrU4Z~b0}k}H@_ycMz^@VafVht7oN4?sd>RctTFt;HDzEk8>kD!G zqw_RH=pXR4Y(CxNDf{Jb^t{*F?3!mM`=Ij10ZYd}od$&u*n9a^fbv&!1)JGbbSi}` z=#z{!KOtH9Vs)GPLy?2^m1|H|4hMgVy~2uV3}!WbEs(d$ATVZtaE0#%#%CKJY<_qj zCez1!SNIlk2lc~(W7JNT9JXtEYp*1H1XpZC@bdhnkr6;b7tqZ^PCS&;E*-i(;%Rr< zOk_t}NN&v^y`csw-pM0Pde?mh=X8gY$orMb5TP2ubts;XI?YF}RhIhUeCu9OB+DLo7@WDV%fCg9zSG&RcnH&b6Cp7^sh!k0lhLOX~eqQdfXJvZ*Et(oQu z{HvTEl=)MRNe}$k)NWOA?FoLXzkNn7?4%4`VF}S+#vq(QrZKhxd+C@v;;`=uyuB3Y z1pw-E8lV08okx`nR~IJAm3nSh7=Aaur0HuNJ>=@UmA*QMFinX3v(=QlGXaZW)=xnu z4-xq%%HSp;cDOn%;SW|aG9zA!7oZU)g>0}<6!x@Yzq9YuZN?%{v+r&4*&6!h3T>fx ztN2~TnD7odDWXTLkH#<l$`Tf4YU$Sdlb@2qm@_hsKQ=hT# zVfP+CcvVh=Ajxq`NbFlteWT51oIlF`Ovq1-PwfxWK27Qmb{X^~=uVm&WUs7Mh?+)^QYZdGB@-}b{G*Iooiy>=a``&!m-s<&$m=l9l5Cn8)i{S4!W|1=Y7w$k{hK0{k|B@4#Sm)2tzfa&&!PPVsnP@*gR zb~pIE zuk=0P$9*Oj=i9m!%!{^ua3;e%@ZRjxe`b*n_GD1kH=UpL`S~r{Bqb~bLk9EP<}Y|e zd0Y1yUGWu6>0ppWRrCY){-g5;w`p=e%hxjxT*t8R^!iBmKxfStc@4E6ojaH%YxSsn z)aIMo?0#6v9i3}k?-#2T$}d^(-cNNpH@pvSRq|e2{O-07@1T>d|FD54`Dn^39@p%7 z^w)Hn)CB3}CZ#|L%Kdv)o{z)gNPWcCO86+^ch=s7%R`&eWiwHSrqabat&^!*M`?Zu zy_85PU05Vce-STF3%6+4M?gEmXQ0Oi4~tpQx@Vg6Z4M!)-j6@a?&fqS>l0pv@1jdvqMxbuC9rF4ucfxk>VD*cUn zXthpBpH>pTH}K2U#K)u3@&!{o!u0Z2lbw;RsSOv73nM&#^6LqBv<`+fH9|9j$DrGl zj+ub4Z-l!69&aE+Nx))$Sb74}btD(oSXs|T%JHFGKJ)V>o8GY7TQkCap`Y_g4waPZ ztDrAqkN7XYV)-W|rEe!0n|4kUuD!e^(7PftGR^>T#dcN>>YQ>v$h<_xhEOfsSI9T<7HftGqX^ z_n^`Eo*@l8fJoBSRt1=D$A)#1AG0ao{&)F9%&0+zMs{lTm{t@ZMJ zogesAaejsU(LA6W>-Au71@dx_k`^)r{eIL`~5^*`vFB^)A8olL(2TAa!w=XfB0We&^{e`us~ zWS_ULP6c^HZU&d#%&)r)>3;x*otR`SnJ7@=alxcuW444^0xHH6laD z_yhck#&7bz8Rmt$;GE5`rjUMs!m_=6NZ_#~hNqnX6DVSRv3NdrD#j1tR!RGDdGAkK zVt)zq$2W$5iM-z%K-33G=x1H?J^;iCubmmBO?ub@rG|4zKlAGQj#>k6l(MHq%sPLY zV>Y%pup3guMqZx(2>27(!)MX4SvBQ5LDNtc>|(B9(JQhq1b9-r$Z(7B5;*dlk|zyZ z0skWY?6E1mzxaX$%QZ@|R({6OHsg*Oj;A0P1~s9cXIHitNA>#-Me(6VkMEQ|UsKOy z0ac6}9=fgouL)dW&>n4z;jiLA$&SN1%efN-1eAl5gUdpvrP`6lWp_m7%Ul-jR#h5M zav&xVX;Skql=Tp^-B?ZLfZNY@dxQfKk*;w&`!x62#}gvGjOVZ#pRv;s1MbyEl_e87 zw_`$~BY8e;ZwazcgpWn@EkeM$Fw+ZDE;*v!FcEpMOyG&<3p^3;m)Z?)6ZWO-6`H^4 zVYC$R+)Mlxj2^B!`vAi&24AK9T5w)iH(>k2Fj#Hq!h0W5(mg+>KeAM?hMr&$rnZRt`2b0 z-?Y5tI}Tq-uq~3;1GYkgrUjF%bKk2^T(|5_| zryXGX2`=~(=-_qI!!mySciG2F=&|O1KEN5IZ}d+p9Y-#~p8+GAk_Izf26peo%QK4H zCkvV+S#N}tZ;jCK^g)l5_7(HaWSO~CEG^&xHOmqckhM40Vgb}%y*420eD8hG>wb0L zq!>Tdzh3$WMu|}(iu(O^iKO)PVRs+xs?Wzz4U3AhFi#)Lja50f)5JWn011$=fgLpe z3Kx7hh9Hnet%mvc_{$WF#-v*GJ6C;fKA)P(HVf45XNYvB$$j!pbwImQ&OQEzKyGYv zO64ti1IfO4O>k5%d{aci)0#AYt}DaWuTjY;{^D_eO@#2X2z0`k3nXy0A3L_P_ag@4 z8};~9!fz9L;2|J<1#aLb+Ck9Kr$&JW6WomZAAJw>AWfpLTf%ewf*y9yJi#;iXV8-A zN(KEB;M@9wMzUt5d)a*X4KB%OMf!IoebvgFT#@dfm$#DjP4}R`{<4Fm049>h4F0M8 zxM?0}CDfvb-l@y|xz@*o6Zy>j=J(#_0m@frV(ose^d)w6ppmf_RNL=&2}2ksW+ zcaI+$61brikeqM%*Z_z+qcL^fg4&Yv7N6mb2`V|y;_GWp*T)pG;vV*Ald`|nY!A5Z z+am_t=ibff?TDneLspC#+v+&n6Pdn1)B9AF`?{(qKkgIc!Q}q+ut^lWBi=!SP#Z=$ z;CA?-Y7nRfqe)n611-cq8sJ%?0 zg90jf_R|$EX!Z}_hTQwJxiFM`l}eB=NBgF7{xRPC zwcF__sj(*NNh5HzY&i39juzrmtOaKRk7LgciF8rYMZ}zb*YAU{%!~= z7BhR8a*F3~-Gsaw&u)7M2fzJxhg^B@5mnPQF)6Pm4E0B zpUuXkeS4$PpITbsJHy|D)JlTCDf+Xsa*FZyad0N4KOeb2p+DRC{ssD@@ZkY})xVhj z9IABDpFioL41a}xW%TEFvNzhkUz+~xXZBjoE71pXH=F*DmzBhS_ z4Mn^@HjgFpIk=MeGmW=CFp*Oz!kxox_vOXe3!jhB zZzA@>5mfcSws00=mcUD$qtFVkTY>(+6yPSU-e891!*)9JIJ?T zy&`vb{n^K7F)0HA0nOgY=n|v}K_%D=w}_Jvug9|&UgKFNa~9KAqHl#Y*+;YeNKO25 zLn#|`L5%yHJ(@M@8XmDbMTck>TaN9VcEmaMdXiqf|ErD%QX>Y5Ik{)%($CO zaktq2wM1VI9W#8asDGE}QyzB{dNsN{up8b&{(M1DicBBz^sO;Skk0F*n`Qr8Xo9P# zZI3$#U{|nzdU%xDKLM$E!eW&iX#1~VMtlXSeuzXu#h$XiN&uIB@~@AXNr zp~Ro~NPpk@ZSN5Kq2@JDOu7v^U*)!)M@pn(CitxO$DF@3{#Tl>L7H*y?H5qHS1|T8 z99~8au-uDM`Tf zaR*VHbiR=gG;j2Z5%*WZ!b`6xv1nG{KZo6swlI48LW({^zh8>;j}0+8Bzw+`Pw3Gy z;@)a=p)HEC_QzVUFWvbB7Sk`Xxh%*meY}WXJjfCkjY;k2mCPrT^dBtW2m5-Z@w2A9 zt$QmS0;qU4sLcKx{Ez(dO4fIRA1}&2`|%}o#INsJMnYNJceB4BR`k!a&&KQbMei@| z|AoL`M5LyEi0d}1a;9VF4|B@lfg5sv_L$SOxuKsn5?{J#Fm(Y`cH~k9*1^sIl{SNw9md6*Te{mA3qW(3$ zzs7M~AHf7PrsdDDUSoOrU#Ne5%xtTs5`54eP5=57k120}tmT-(wII&1*ZuW6`uW2% zl>M*Pzs!6dS!2CEYWAT<*j{fSnSGn-e=-663)Gt7eDu78pKwLA1;*v&he9ttLFUTHI0UwvA%2wT%GNh@)*+$hIG>3E{IV#s?#cTU$W#T zG2lKV`&%RhnyIc&*J@Hbn}SVMt>>{!JKfI@cp-@8UG73m&0g&7cE2J$>u-u-S9ebC zN#YsHK=yIUuusv;Wp(`_-yJT~bYw{5@;5hI3E`TVKU!u+ZR1Diucg@;!;JZYbX;{N zsIK0=PDvfa7Vc>-NUZfKVTGl z+!*^|bzaB8wpl@6^?8Z@Bl^@tV!|E59`8Lq<{5L#{eu1(=;JO^dyy2`g5c(!QHFPo zVdC$wfoxe9JWOVKbZDwtv`bbx+Yw}hX~oo`$Ke83Bx@VlyBphnvC;>Ju2vK0sfjCn z6I8#h0VL@YtR_cIWPB5gYpNFQt~Q_$HSU*DZ>{R)8f$3h;)Wgfl?g{slvH~7m0@nJa(CMz*S4-r_ zRM+L+XM@ouc(?mL>3(Nx%ycOt8dVe!^bY8$38*oQN z9m?pcB<6U)?M;%I>UDVe6-sHcLf-m6N6*QerTv|J`^R`J9aDd^{T`c>lzglyp#wC7 zbhdF;P4%K(&5s(heOph1#lH#qmHET9se9XIxuXQ9JlEp8HG%!jeV!4^=y7e~iwgS% z5xmKY>8(|7{@qiEtjggYGzeuNnCGwbzmV0U)L++q23!NazKZ7*-GKUfFN zrVM@4RwK!}piIrwkZn143l93=S0U%;R@BJ$?L78S9aHt zY>BqsBMrE$bD2REESz9PFXemMR($0V_rAC?UjE10=3#c6ni+|k(0N6ejKQ5m-|gKQ z$k5Li#L${(B->go%}_xV2Ni{O8iY#?;t7>bD)WQ5H5t)acXK9A1hAu!&psXVQZM@K`)puZNRmqB$ut%apn0LyCTY!(9eLc98+SM zr^#iIui|{!1!vb~XH-Ytn#IMB_Wg90o&>n>dnd)U@pSR`Fi*P5)eXD|U3yQ+Bl<8}2y%4Bott_mulufe}mETrOm zL~EU{FekRNGz!0*p+1((cZ$ADM4m09Uz_`Vs=U#&D`Pqq(PO5OkteiRGdAKjNW>VG z-WmN~m)WF6;xr%2Gu%qSjUG<&8sDY%`x>a<)B93=?pdwJu%ZI~26+NpXPIszi~?_c zH#~pC-^=?WG*WFBY@{2ts~5Ga5784pYtA*`5zptn?$fW9xX4Ku9L*Z#%4QoK{q7>t z{V6dK#@d<+v>(W zWG)~~(zpKNMb1-ps`JQQMz3)FD`G}kn>`|y7WJWJZs;$9H>ceMC_Q@nlg;r+nt)0Yf4-X=B2 z9k9RgwzBz2(Vx-q!%(>5`uFfHl7CC!Q$#OLH~y|=AzqrMZ+`unJUx!Qn(D9dbCXA` zLQj8U{g0I{A-_csO3rsIR+nS{WBK>Q7nPfnV=_UZe0GSFMO27s0cF{zHALCmp}8&Zm(sYlWRR1;(|1 zi)dvjeTvJEh7T3$2V+zE|94pVWbqfTzv%!}*kza{?yv(}rpUwyZP=?8eN0J9g=f(bs$i))kzywKY^Ry_ zQuc7+O)CCQUz{4u>O^mPTt`$K#YDwTRva$8Ob2*bNE|)kRM@3@ruS;Gc5J@z9-r2mh3xzn6}9zObi`Rmmu^_tVcQ?O)`dlDcn*`OR%* zR}PW*)|#HT%2%g~1C@HMW8&%^v1vp(jX5UxI37KS=0mv3K~%Kn1)wI>g;L*62tRw_$ueZUwi@0%vNB59!-jM5Ag zz0+@e%eEV~DzlAxUD(rn(iUPkeGBv1;}^C)a{IzuR*`A_`vs4jzsV;oSq%&9v?<|q zvAdr3)@2^5T9^4Pe-BsnWG+P+fCHiUE7p(S#r;HGRt%ccan(GtxeU1KeZ_H1S#r~OF31M9H*?KVe19M3cV2jo z)Sk@!V(mk_OHyX51}q-hPtQ_Fx3x;tEI88LME(kTu!3Ju+LCK;T0Gw!vUJm?_RP~Z zgU3Iv!CT(KeDm=O*SIMQiO9F`+UlxB$7jQZp9lNSu~vFqKdoE0`rTC@5QwR!-%aAm zdL9jJL0#69CExNvlHbLv`e`ZGD&_pB;s^J!QCr35TgA0EEqU7ar#Z`a!jIMNPC9J0 zuOe%e)oxY`TG6g8DC8conk=C!z$j{Dp@&Kr@x}yrt(-8fIhMoz(+@6>?_bjToz8?( zwd6OD{Ee#GEDz4pb04iiG~MRg$3l+dEtTMl?YG(ai+R-ANv&P1JO)Bk0BwWmJXJV^ zv1ETW)Z?xQzgO|Aoii5x9UD4)9;?9)4f1U*<&p`^ovtE}zc|dC!K= zCtDdi1)^gAt709ZgF2jxO=Whj-@PN6XoUddw&gRPM-WVsne1WZkpe z=Z=nw&d`IF*8I=2w7mW$`;YE}2hQ2KxplL1_W&0rRk5##CCdbJ)lc1eG_s&Bhh>+kg)MNF^Q2+39O?Z#{pC{>$ zwAdG9dU@>QVWAGXoUS$1CUHy$xv)aFkqx?!+l{A8@O7WnYB;*c9<9DP`Zi4K!|vn} zH8UXGaSb*kX|OiGk$e&g^N~LI9>$>X!OeQ~a!TOObs)e9#YWsduPlQPXp-a?baOPr zJ9+1*T*B;A{I}l2GU@LQ8k+BK6Y^4M-pd=l{$a*OAF!Lg2lnCTD9Uf3e}3H0$~J0y z8x&S-3dJika%Dt5j3+67owC#A@2*r{;|uMp9r~~X#UitV32URtbH)YOztgWbn#96S z#J{|JJHq&Y2j&PL574>qd?qNHuU3-l<2BD%<_^!$oq@GR*om)w8Kn0oyeM9l$hy}e zP01+N2P(*qsd#4j8IHYt03y9vUa`gVPXqCu22-)P#@YTVQchuib%0J@N8};fc%y@s za1IFqa6uj8Blf1uIxAJ%Y)C0^6x;V~&t7^qU)dZLhV+t_=%V@8{7_2xsqX)4{bRy< zD8U!{HA*~_1h>3JL0cY`x1cK6+fLVbgFn?}dX|t~Ouu}8pbG&;;BOpXx{|(UG$imy zVcS^y_ofA&qIOyH=WD9{q*kD>dfch%nr9WZ zpX_C0b5fC%EE^lfdV%NLI9LZqpRegL*J#OC@|-y2q`in@=OQ3wwq&D!74W0JsCSaz z-ZGkvOlp^CBlKMO=gl_a`FNyhO2n5-<&g%e_q_2%**m`S*4W;0);ii2pMUA?9iFaK zwpUlOFOFIMS!`q;Ph)(LJ|>-p@47&UeumKnnd6rvxxx{h>jv1X;yGW=@9hGtTb`Rl z_F65eq;MbK_PM7q8N#ki=Q2+@?pGPHB*j`*T$w|{>mgU)LMwLLFc<@$W0#^LVt&o<^RU!dK6$3G0Z!|AkL1U#w0LL6|r&`}KD7u=~S zjObS3V&vCtg8ZZPe!==~^*=x5OSnXd|2@3$&$)sH(P`flrWnVzbl%Os-t+E2AoH|htY%L>Wu z7B83a{I>{c*nRqq`zddrQirMV?O<2C`XmNi-G6#_2swlW-y0%9ZyL6SC ze*C6QGuzh{s%9?TD1C6XI}WU!xpAGO#)CD~o=i7mttz~osb86E`O#2LZTe>%mHdN! zY4|?ds{QJ58c>hh*>}Mc;5XR|^-+QK+ASxgZAo`k>pp^ucY*!_X+zuEm@)L6s&96o zAJtJmCaLI>749?2*~T8*^tk`>Oph0`W#Y?EJ5R`;-#)w7-Hc?48~Xp)dlUG&iu&(A zDXoO1CI$K<3P_ZyWi=HFg|f8L3%Alp6{AHc;D$v+Dzs3ALTXyc?KM)DYLzW2Y897& z79v`?rL_r*5&iz$q(~J1mVPVYi!yQCh7tIrcJ@mKvW@oDqgQofeiP&u#ZeW^ zG(fLB0KItI`hH>g@9*;3%76W?S1r0D7csvAd!i2BCwfS33(z!@Rwh|K4v9=))5N^pPEZe1m-;z@4aXgYb$q z_*g$xe|=xG!mA-#lr`2j;ePkD#nYy!v@tl|@&;nL@2l{D^8F-NO~igwkHqJ9ODf9S zQ#ICp!Fnd8htt1{?aQMI?aKgulv_37|`VUixp_++^JSquiE@OI6ttLr5>G6Jzg9vQeBGi86bkkS<$KWqkR4; z+sWUqKKGyzl$pfSg1#Qx65NMqVbqF<0A-{6gg$A@WIuX3s>Aeg51%PaXp{ zY=}k~w>wStS~|d95w8pv@slwB)8+S+Yu0<;Z1S%A6CcYDDSz9!u?MMVA*@23Q26Wo zgM?_ysVB1PtwIV`3oE&|E7koULk`1k@m62oJdHarOu4OjlRJP>1aiTJPe>|`RpMfEg<_DJv9r%z~kgXB=9Ah|T=yMcjY8(1of^!k{d3H$U zdtF07yKo$J9j|CJ-XRm4?1NNZ2%pHmJc~Ybi-K9}>lSUvVg8#Xko?hWFPWm3>zjG8 z5KLj=R`)w)YJV}zA&__WW|H6=%C5de&+v`)ddTyQeDgMbTmK0DesCqkS%y7b`_M#S zY&G_1iyd!Q!}$}aHZE47=sa`|Q8M!Bvs60|eQaF5KFb?K^bzV{9*If33r+6ahxR_LxO0@ z5WQ)o(C+R0gCrZOs9wH?0Ke*6b;FrSyre(H*Z0c3aeaGReNU4hBs=W$ws25XMWMfy z{%lX)-gAk8uRz`w>ocfoLFW7Uw)nbwuN3D%IFJotD1ITMniI?k2^Et&^>O2h`4 zssQEXP~YWAV||42azh`V^yxZnWeh%{k+DoMnxQ53M+NvYe<*=AA9?zv-zD>xm-k}! z+UV0k2Vnu~U>7xXxm9$>EIu{^((*gbR!2>sce~6z>PCIgjxMveN$#FYMWgHKXwL2Y zxJvlzOi$UkdF%A%<16M*_fq0C`W~djOtKhrcH-3=jm)cF@??H4MFx%#uriH*7u_GF zggrvSz%C$z*CqtRthJAP7@`B!yA{l@@a=DR$N1s#?QRmv;2XyTZWrIA-wls1@Igd_ z{GnPc^w@da`TjuG^7!kO_CbqZ(K=gjEaxXI@|SMcKjRNdJ^=@8p_AqxHY;VFG#^01 z0{x_u=0cwoIcb)K*NHFxn2AX^X)b-#K5ZSl%TFw0mRX+ONpnq9N1LlhTNX~2IBA{= zWybdSipTr!%_DL~$cvpcFIz%z(loqinDV>lJ*FJX@cw6-P80=A_xv7ie+2`iDNZoK7d5H1o+QanhVLUl^O8?P&cxX-|)2!0tA5Kj=Vq$-R0k zZ%>Q%w}qd><|o#tAhv}6()8u1vBe;Ene_p`A1ScE2w$5wNY3@aT_6f{Sd01mph;?$ z3TWidnsEzPnp>s!-|L-UAMYk!B#jFdLtFjQv>S%+{n1ia5K(iL9#q;g>mfE?TR*wY z7laoYe~#sm;C0GB)bjt<{eMKYFbvZ`y?iV3hZpp>9RJxyc^g0Ly#SE?fA>bRtiYd9 zQ2*oyqB42=v9$g=rnjuTDW@;w?I&S`=9XXfiwN=_9o8#2I1)kH3yWnz9QK8j@Vb$` zo}<_78%@=e_QCyp8kjF#se8uZo-&>1|I>~?w^-J*w+usG4c2Z;I{Y!y<3hCj0)%xCV9<^!P z{(QgN=DSxyB+Qo_Y6*R*u>ZmS8(x1DO6KWVMAB{)0RiSI_-9d)UoeD>Yy5pmc{+Ww zXkSN&7@cnJi|KUD;|V(bdp`ZIJSOS%F1-gjZRMMYPH$Fvf=+K10Af1z%a1XB!+nI~ zJN6#gGsDT-ZP2efgL57|9>x6i^{v0{%Hb&tyWINQrH_=TcHi(xk!rUpyiVL7B1$Jz zyK5f^s@-8eBdOZuqB`2#SgjtEQ|)$-RKr(qu!@taT~qizR_*q;!a=pW=xIL4j(yT; zSiSC}7yM7DcAxx=^=yi?xYO+!)o!LwG}UgJe>T-_k}uHW-sKO|C8Ow_mvu7*%?PQB=O1Uj?x)!Xf zK6l=4%xZMc$r;UJD$v3i=thV^wWfHL4X0&S)4Sc%2v?@cr_^cCwVhNDYvqy|)iR$H@6qn|_sBx^kOd+lzw&@)je~4loxNJZRScLLsmd_Ks1ck$a zf}&`#{N_v+(RaE&wydBo2ru!;+%nsz?yB*`-q}NVQ(a5Wp`w=MbF4Z)*st1P`=8jN z<>eG$m2>-Pc3T%VF(;h5 zCGgw>0RYQz!55;Fwyw1z zsTE6M7x|O6@^dVGBj|_b2L(~VkKhZvLH8bob=1>X-{raVe5+3@qv(9AOGqW8(a?W#zSWBlQK9+O z6A*8H6nfdg@i;v`W9^cu+VIp zD&XU5`SnLv^>TDoZ#cT@9pcH!(D?%XSzwRuV+f_vQbmn^^Y&!S9T+GuBK%LVigZ3b zZuk7EGYrtwADv(IUY`)c+K%NdI=|{KnvzL22b^DZXNN$_eaO!%8F%%LpI>#AhVQXa zH7w9;+-W%hL&(~+GX9o(!~=piyfD9zpEbwj^2C?--`6E&1PB4}#M&BT|52Isu%PYx z^)OHojsGwmKCgjD;~#YU{{u0}s#Xiyz8^%SPlvvV2wAAxR=jB$|3-ekd-6MZy(IYW zKdIaq-Vj}Ys z_CIQml%AJzwrI^0T2h~Z9%FnddtS;WZySR%k$jEI!-WL5Jbs<;Nk55S1@z8NBSWbq zy@&g;#sgvGARH??qlBdjuNR;Ner;65j{4j?8U<|r->7AB*wI8kW04w=hj7CFwfS|s zq5c)oS04Xp*=r->H?-Wt(E40$+_G~&{a~18yNfW|k8H|f5}$^LPr&~qe3JTyBLi!u-`~P=7Nuj?Q*e3mBhKN=FThAvsz8_2N{P=v5tM%#` zYY}~l`2_rpc~c(W%KPtp`FnI;EXLE}zm4!dPaJu95!Y`XoFBz)B>10Dx(5jMfuZ7o z`SV2PsCaCF9YjM>;DZm6$v0RyAJinhI)U%(n?i7s;1@%Bf0M6DA~Wjmw)`(;y>`~&*+Ngy#Qa(a$-3iA9*GP-zcnwl)07R7|W`2|6J1)d0PD*D=q1DU)I)@_KhWISq z{7PkY^9iQNAqJHEoRXoW{xzFz6;`(^&S+gFKNE3P7UTRCYr@CRzn8#i^WXgw4PRCG zaO&qy$DKr5mZEQ6zv^vWWu7>p;GJ%h^?QBlpOl+;%tO?Z9edNCRb8(;kZSuks9#ua z*v-MmH2vt_d1I-!c`fQ!uloTbn{o6j^PlBZz+01rXD^$6^kbo;VJK|! z8@%5~L2d9}XYg*tk!72kaW#E{99}vQd+qL0|FVM0Iyg#kMfKvG%@1#xR2xOw+&rs^ z*Oko8O84iVh=^(xFmSg$(h&t#<>O7bwMOgzxg-4XGgH}adgBTWVd6^r8Lgk&H)77X z#j`X;)w@xrCs7{ONSxP3{0HF|>MG(;xP2haIcJwg;3fORnO>-qpBRFpJhN>O3P}IEcOm zdZ8Wcbem@*85xuOCF0}q{;JmFMm~bS>g2m9>$%;TdMxr+<>^)2QSorE;k*?2H;eSE z*#EVI{35T9d3oc#LbgP>1LviD2Zk2{uFk&8GwNv7u9zRozi<1`O6)D*i*S&-P^{m+ zCjITPmxa~P^m_NC9yL*k_4ge=FD}V%w|`#BQ@YC<8m$)9ybgULl2_YU|0q~5EY?4Y z<#TK}rC?WzC6tXQTTy?7KFpx6&jj}Ez#e|^|I_nKo}8ljlq>%AooDjG+X6n+ot9jp z%*#JJV`YcWGx^n2e-Oa#?-9l+8cog;807#su!HBBXm7}CJ?D zqvE*$*bqY(QYM&ZtS@Q(uFHzS6I!pEWI9H#`>r@$@C>gq;fMdQ;5?JwUrWD;&NDei z<->UER9B+UUi``Y`ivRt`TC}`EZkas zYieucuk>{n>eG`*r2Fy~;X%N&2vz!3lwChg2lD5u?8d9;6_|P%2C>HDa7$lvaTV>WqYuM?Sf*j!2_Z+EiO0Mwon7xF( znxsv($9W6sIh4I*mR0EOiqohK{&OlM)-hqDKY2d&J}I~?4}9plSGRViw8yui{|XV1 zv7sJ>#EQH*0Q>88pJAYpIdHirRJG;x*slId)FR8Xzhg`l?#g$IYjkp)l~67o$V&RY z(v9!~krZ0##`=MrV;u(DC)@gL^EhC7+XAtRC?^KPcJ(7n>eQt6nf8y}v^XpAhU@h$sR5t|G%S3j&&uFG) zr?L8^gRG}5{UjOMQJj*iHfM!4Ss}5zZnvB9>qZRqty8OSeQ`$SIZj@ho>`Ob9663+ z70$2UW5;Frvqj_hbn86-qa%{Nqki@Wrcry=ISO1~(*((csD0ui)-N!1;ZViA8Ay>K zCjSbGy93{7r@&0|X>=*AXm<{A!b5O@4}51$MyHnUNh&js)Pz5~2~;`o7G~e16K?L- ziHE7a>AtBRW68Es3k#;>dHg-ZDL!mn1*0VLU$nl#@#G#m#0J*iw{RZZzQC z9O7$e&p8gXVI(&@LOmorup~3H_-gYzKx{*$wpZWp(-`CIX9Ls=juyjvt)}BA5h|XR-HE2aAd$&eTfdW?jCG6_QS5?{v)jr zbHpZ%>$Jzz)~DCIKT(7an`j+$f&b~9-#1;ObTtM;O7$#F*Ec=BrA5c=&1W)JcjH8G ze{R?!zTCRHP44^FRhBq-Y9i6?p_{uQgs0Q`O?4rmffYMT`rlA})!R@oA^%(T^YM|3 zxI1raUl?7#zu`tIa|29O%dw#kO?PqjbbbG!`p9H+QNA*3l-ay+WyQQ&Lts#TYqxO5 z%Jz@&(+DgURJm@{L55&r0E_UWjN8U!K9m!0*PC}8Ri}mJgnn&gL;A$goRGz5LpE~T z`R;CE$G$!tySLBl^H5O{_p*s9U}TBF_uF^|q*iaFR}(j^qq6MS*=yB8ulpMn^k zJk(aCi=cLZ&)y-RUe;kiHBksqcmGZRsuJ8YWJW-}o!%HwInSbX;vlX%Mls&x%W^9` zn*s*ZmwjH1Niz=&KS=nj5)PwZIV3X#3^&cr zuQ7s9JlP!wCHPFctHASZrxmojmwv{h&UltyFWx7;UYhfWX|{)A+1Z=7ZoQH}{a(x8 z{jd7>1A$)N;U3mgn>U;Te_bgbf;&G8el+K1!q!RXbT=Jk^I`(b+LP_qN;pOH`YJfp zkh_}#C{m;Pe?#4Nh_WQ&c_-#*T=T^BZb~aHpVqm;Ae4#bW4ho$(__dpa=sdjX`#e}Z zZs15EEOmeK!_3f^>}AN!;j?~^*$Z8y3my$1DeByNzaGrT=5^=9@xgT_kIWy_q-{M6 zXmG;Dt=)8Xh~A+Z%HEW{%0@OzNctBs80MIOmcvYKtj8;ABOh(OyUoAqh`;BvNYG7d zZ7758jc<8X<*MzYO8+7eveAQ{`zOBP$13(YW(M$6C=z7;k}t5rU3-eb_;9P?J}X^o zZLYQFdZDQ_1^nPE^bLZ6O=tbr>RH2;#R*WEul8s^lT2&#L`y9dCW9PVVr^t6|LaOG zasc_)zUw&+sZYH#;Po;qG(;g)>h7x{eOzdBpe8(6nFpgXH>pewX)D|mrGiFH&h5z(!BHVjCtuLH~-Uk@730Q$Ur%vv{-^z}o9mf+4Yni}(& za@d9Zy;ck)?$kL+|CoxHV-d}7!zo{@de-Ln`aA~^-0e8C_nzj@<%Wl-1cBWS9 zM|S3ZXkx~Dj~hUyxUcX5QvOBQD*CepUUK*^^jYEdG@UIz{CD1a`7pmjnIYtKaI#hs zPFI%vBDWqt!sCzZ=hjiW&jmL_!djRX<5!*Gmo{PTpnuF0mjV%Sd5BUjUL@oVFJIyX zI+uQ(^D9B?ez%r%I54wb~+V6_q*)2@F zYZt+|*G(7~sCEVQz*V3L5$)5vlB|P$+A@t_wv-;Fh==#M{StM4lscDk#;`ov+39KY za+tV6rH9-}DrQIfV$&G0#SSib$@~tt#Ok3%V=yq8Me77XFZJ5o?#F@EvAv-6m;}9m zgx?fiAfiPtZ?>Vy`_n7VX!Et5^LnHG%ZO*co-cIop|(E94zg(V#NY?)GB%h__f_jN zlpvt{4bCC{#cySf`|JHjh=R!Hw(07?@1M~_SZrBLzdgSB^`0pdXMX0xnPzumO7cs8 zj@5Byh+FsdTbQ+08Rl9*=+&O;nLf`Vfwe8UO4Nu_z5eHv8GPS3`S!hOR{0 zMCZjEN|!hu{aM6L~T<4ZoaB09j@nxN&ZKx#8-uQ z++S!oLQfiBYeUn*t)bC_yoOb@A1lY7$HGOZL|onJwALG@Xr=qSbz9Ne-EQFx*41z* z?}g+*TbT7shAq|lGv0OIA6#8B4lj&4J}bm;YpVTWy(`=V8z@A#<>=x4xd!jOaZ+kp zqWA=x3)Yyjx-o5+^nqRJHA6eeJfC9xPxLg2*$^y*ZT$ASojBKp)(7ctpRVt_gdTGu zg{5*njvd@2#MfWLV0uk|W%}r@i*_XeJWuru)LGV=J^+aH@G3>0yP!i{N)5m$7QW9RvKBA&zJx2lZjn`#pAIz4y; z8C;ml?`UYz3TXmg3+O|zm?~43-_Og~%pRW3o>pbNuXzoi>U4K1TRoN{O|iF0M*x}F z=oyl0+#7wGTaO0sF&%xBG(?|xm)+-P5T4?z#u}%l@oLbc<#C~c-|IIb#5_P^{XeG1 za{Kv>9%dTE6=+8bM;h`^u9%0i)@%Eb34+#bq`cwnk?;-By4*^#zoT@&fv5lMrB%*s zzXU!e{BMAx);;AbiSV^>fA$xY3Cd)53y8}&wVfm{4+6e8&=*|6F=Y-ao`;F=EmNMd z=xS^Jxs!Jkzk_fQk6a0T&W}g^4e>cqf2nVq@CCAbn_mw}mKQpd)ECM#>O$ltD!$b>C9y{?w6osK*L&QVBiliP2|z5 z(4PwIcTC>}9#)pYdHRaZho4D~m~po{rTtxj<8BHZmDJtE1lRQKG`-T!jd|2^>~xqt z6q{{1_PW+`?68;~9(_*9VKMsN@TuHkF%f@czUt|jmzOGG&8FCR zVRp=fjp+l|3!T!HY(g1>c{@~bMJ?a(-K4)(a^#`MSS@tY((Yf9)h$q!x;T3Tm| z^g*v5mE*^Lt`hvBh<`-!NS>N~yr>WZ|G~F{c#Te2OUSQ!s$~WYg_&a}#Y=i|;QTfN zDU_U7%VIAxqq~0pOSE{BAZ|KerxQOO7&#$_!lG>u{7=9~G`}YTm=mk)-f9?(p~!kw zFdz4nU8=3yIyvSC=DnDD3iw%h{{0&YMd+O8e}ezuj`EubUcLbn4zr{C5mE2;-~Rr7 z#NYi^@T2B6PwnKdNZfrjDN)E!Vf)}Bv{-IEnE6WLZ`6KrzTm)6?fafF%|o*O02}98 zX}#xvW`{Rq_+E>(*Ob>ITWLlBo2yf7%Va96!JYsKZAvQ(Y3M*6%%siNDBq57LEv0d8d?Q01Y zYA=N5j8xr|QytacSmSqXPgM(B=$+TYyWRJszc=S<&?1|HBD9rkbK{Qc??(?A5U`@Q z2foOPfs8=(7e*r8+=ZHl`svRcB-nh*}1A1GJ&8ykMPG z577D7r2o{PxlnT#dR8+5%n_=%sqy7dT7rpu*UN6uox6_%hHX1w-p zvQoR%9pPKHMpwR2ebyTHZdzbShvYPZHUB<=?u&=K_S%r#2yPQUf;^e)}BZR<6y ztJQ^ct3QQnEFZH=Up2oB02P|D)wN4k1ixa0s{WBjsDXW`WdWaOmQS-vIAyyTv#(V6|KnzC6f&Erj14Z?#NvM_S)}G}|#hl#2mE!CqANGqnQ; zBzv=~eeauii+%5Vp`IRQd8uwe>x*Wu;v}+tozSEd%NBROO|W*&US~@v2=ht$s&#d} zfv&L^Ka6X%iY-cLsYMRqz{>%y{9RF5+n3De7P1XmCjqD?hv);86Mjpl%J3vbK_bX#5 z1R(Y-Q+OEr%Y94VfVvVGK{E>+y}&=BH9W=~w;kyhNqBh)=D+v`{%_Ku&!od%)F~-|A_Ptk znRM9qoq6fdm454*^e*?gYk$hx1lLvcx?9XGx5MrJUEf^KH&MHPw|1}nerdZmzN56= z-{GJJQazyHAQn`QYvw~QK9~XzqKoA>H|Sjg>PcOIsC15Ro&=Np!t`CYn-Hc@A4|@^ z`&(?wm*;l}Z%_ZTISfsd;eV%;=124oT3~wswoT%>nqtPutJ7;I|0vb8NfCd7e@F3P zF+XG-_UkHbPz|ucEn!Umb@$Tecs}YK8x{j zFn#{~p?dE;?pI(+aKL$ax4rpJhe{dqdoIX-RUV6Y>wl5I zzZpOOA^L)d2}q;Yt<<@bne{W63Em#wApG!0o!sfZ?5JI}4(snfDmsrIapd_)5+D5v zQ%^d3BI3{li&mGM_d~zSH*BysKQt=E!Q96d@MIZVxA8;E^NN#6Aojkbcytkd7Sl`7 zdt}cxZR>POfGuxSJ2e_0Zyk>GLckx@P4ZY?mckD*s8S~0^Z|DFQ+(Wa%+%?oZxr_j+jPIAs%ojB zo6lGB+rzJFWImEL?ibbgM|}}$yr1}4ic=$hlT$0_qcHdi`u}D_^NpOZPq1RWS&%$PsAn*_^k$Zu|n7$$$v%N+Cx)}|c0;zGF+`B;v=AlxxFivmH+>$d>zLSDbS z74p1Z>+LaBCH+xJ{&S6HtZ+QV?Pn6_rJ4N5;Prr%>#X(YytKFR78wVTcq#9%ER_9{ z!J4tcJ1vX+$$9u+)(YAd_P0QP8Ymr4GT->|ZE=}A|D;eY9RqW1&79v}w?C+1jFYu$ zUUQ~_1_X`xG4~RjHT7(H3!A7lk`Hx-V@$}NGWrco7ne62$**6Y`-4aXnY=9Gf3!6O zMi-xVK%-_asPSR^~C^@+yL&6 zZO!jx*=^<MwI%kbEIlu9)8A`Dl8gvZYZl0*Lbmm!|CKk8bx8PAR@D zTAj_qEB?M@{rU`ZL;BOQL;1Y?st1&CF0uT^E==WaOl8g?S=fPcm!lJ1?vUk?VcYGR z24Q$ci#_fL(((G(a@-T?%wJ{Ln*3)iGUjTLJWbO7E5_gb?G&Lu(zny}gdQZ$DuV5R zN8R+I$NlgdhBtlg)n`4=wZIZs!p|(j8%2u014iirgDB{GQ>YsB6fZRUikLd|vap|f ziXqctkyAuZ0u1FZ|qDoc(fGMd14h^rLSvi&~0U!;Tr*# ze#fQ5bD(i}?@X9a`cszxM_Kq4+gs!LpwCZIBa;;TL7#nqj`($~6Lq4vV0!n3@FpM_ z^waIyzrKSgljZH(GVq`)h5RMJn;8UC653({e{0M1|NosA<@NUnzdS)jv|;OoS%`rf zi3m^f8o3$z2?$62KKnG{jbaS=o-$SJ*X6pK7G0r~l;1_|iFjjq)ad^k<=1Q9NO)c1 zyr{GF8XhEU2l0}lC z?4O;e80Sv+Y0tswZLd4aLXgRP>Ax(%8rKR=luM35_h43f-TNrZJXow!y}vKcqJ=H~ z8zW{6Q%8L1y(;^?&$5+cXXZ@ZrbTWgug=HEC-t>5{vGrUYw%}Ba2D^;>wU0jh4q;D z!Gq{r@F(qixH@`b6(cW=68Qy@jsEaawxYhLo|0g3X}pNwlV*a^x#hxYq-EHNMQkH` zhgon^!eHZbM8TwYVi8wSSw-mQ?Hv!#nKZeQQSf(Jl{=zVaFVsn zO7`Ak?Zq4X^R;d0bk6y3Iikm9FfZ(>oUePUy4_d4sKK(@F}KdW2gQS_sQzYdT;T`XSO^?4?wWj5i`lTnCO{tfJ6mp<6dbwQF-Gw@!S7*!6#A}yvLx6 zHoDv~b=Dc6!OLv_(hk)7ApdrEISFQiAEhLBo$}#Ee*X~Ysnu+A`*a{R>e4$I_h4cu zd-GdCz*_+uK-Xd_82A-+A}WIx=VNm2$0rUB)ufv*tKnMUJEY*afze8|>-2u2$Lz%K zX7w}nehz#VepkFvuY9Fd*f?IPRs-I$J4d+IGd&pe3Qmdzn3sQk8zA;K>VwgVCAKwvZ>7+FlL6;vz6KTo152H zI+L%Six>5$Jb#maz+%^h=dArGjO&j|)Z}G}>oV*M`gDzrAjwZJ23;a^+=Rn0^79N$ z3G~w(ezW?uZWfPkyZk+k_CPqgPRA{_r_?{b_v^v(4@Zl3pNX4G$dgj}6uuu`-m7k! zEtQXx;|5;yc*@o{jDA|C{lOCXHr)Nfv1}{v3n|85&tIkh(i~0nfVerh72J~@tFlgn zHRei zwm<+op%kmO#ACDh0TjKTdviK+4)9ajk8s9Go zY2~LUk~e0jM)+=;u_|w(CDTvx^Vh)$;KH-{?R9T8NNHWW(@oT~T*9Q={qCAmZK|za z+@lV|Of^V1da(>LF$7uay>7PEp-;W)P`&s^R$Sw?R12wMT}B~Q&YeYZ3#sa{kSgaI zd>?>br@OhCx+kZ)mGC9>V|5!D6E!BIcu5(RXSZbsUE6c=!X^-i2%M z)-I-}LD7M?fh86RXPxRl7fdrBEHzrZZnSMIMwp~M!SstC41#AvFzRm$=fzrzm}^;j z2My}nQToD47x4?vpE_)bm3Wns3cY-f^go~^97@>7*Bh`&@HVo%;Smq^7I~zf*3o}H z6;74+XB6AxwR}+8UX0Iv{nPv>nrHMeZ#Mby72|X1d!jGpc~BYn!_Qw6KW3~usP7l> zLmb1~IB%W#taZ1QozFyjn%86hLLaosr`70LdOuJMvTf#1nmF@0$P4^DV;N zG+AOT74^jyBpE`l zySLFVD)M+Uk64@jUc_JJ(|^n(&BXU2ep~P6Hg|5JJp*Ng;UYapOSim#_rv*j2*gZ@ z9p$J0F@BC`etINdJbvE8TD0}qD=qH;B+!##rZgAiJtqfP$kR0{DSc?=*2;N%F+IXJ4v%B>^1>q0@4P=9)sxom!Q)O>hKx|97E8Y|-Nv|GkS}!%$Cuxy zxV-jA7nT=)V*I8YbQv5314i{O71gkPP+FIJ9|@*j9ZL`vZ$|vKFU)73tmKM$ zJ93}y>JO=M4Qn=kfKck&(9F2S{oc=`7=={wI=y(dHH`gZs(a%a#zxeM^$X8l&youP8*8*2r|VawM8I_6h07Iy&d!!X~}p?C20 zKB6y%UL+nXe*vZbP1VQW4xmhNbqFpO?J;Wbsm*LDynkQd}~Q zIy(rkp@X5Uq#n|A-k;1?46;_8j?-%U6QIIh`;qk66l9q^yJ1W;j8BF@nRA$*4!5Vw zB!AdpIM`qeDO$&6Jr@f0;q#+U5pa9`E=odb-M&f)nK{dh?l1EnY*3nvz1HjIVl;^> z{M$ZRxQuSv-B)j#p(3eeOB+`ZwXZ?OAqv4i8SbN50N_9ejDqWT2owfYkk!_m(yOw#0Ynqe+s`nYE15d=Ac8B@A+l5aAed;aQ{l z?-U%ppMr3!P402u)-u{+ENoSn=^Fy}^IP1-iB=9)@%ts75#zEc|6-qZx-0aH^%?ll zyL?k42Bum&njHM9Skl_UivKnalN za|`gS6ae@k!`9)ruK*-e@e|@h-oKZ!$ zyA;X+>;WNMgp*Ky_S}*07;$0vUXyPsw<^eoHH+vGsWtoj8x8$`fih zVF5WJ!QexrOrK23N5|KLk+gGvw1^|Huw+ekSbqK+#tB>oZU3L}!bfbI$eQN;PhQ_C z;;+9{*#!zV*JKQ7e*}f;u!+PW?+=uaFpWYkvf>CH|9!wu$RIhm zxIe&8^)pq}D;@CU-Gw6(KBkEbIpU9Oj)VOa>5I}Ywa9e2++ViZw6}eK)sSGo_su!0 zXW$8Qkg3E%U*aW01S_Ehmmx}o29nsApI`Nlz6q3UKqKB&UY$v{eyG6@aJmU8zRN>y zZzPCu3=B}F%n6085qtfse?_vFLae|ZN{h?rXdyvDAq4dEDZQ1I??Tc4CV$X&{H;O1 z_xQMvAQ^6h4Em~kxWm#@8UKOdmLFCae?&_fcp3ep#NJ0=tD->0_S{(BDAM z-oIBuA7Om|eef)3-w4Rl=hb3lW%x-kKabDf>SBs@)>YT^PLTw{@&yaH5)=NIDn{|u z`2*2vff%mdeYu+G{v#BT7BLbbC&_tliez*R9&fhCT8Ns6H3N!|Lk}g=wq~e)F}SlCtl!w{$3v&C41c{{Wv{%W9dD< z6EffPG+fFb&zG#XzUIeM1n;8xFS$RZ0RMLgpMjI{HY445wK8EZi@%hI&-q@C6#B0h zZCGIgm!2I$3QdRQ%+zZ};(uhp2uFTSkI_QMytja9K$PHcor&2h#i+5vZKj_7`wesi z%Zu5d5`6fh0`q#EV+N*7_it#(k;eYed;B!qK@NPgb>b3Egr(Z1bgSKp9r~PhbcRSAm?_>}z z)A-^5NN5jM`wfX=Uso|P=@qD$Z3SoLIoJ0u{5bI(B>V~G;h$9pO|IqfB`L3V5T9$y z;`3*3Vur$*6cT)A*?Sa`=&yZ^yBfD&PQUT=QM7)szxtl7c&+Of!`J^iV^~!9pRJE1 z_@VKS+ggZ%NbrwDzPsnErT+9Hdd_;#}H3t128w{^C3Vqx=whqwbF+5}6iu+ti$ z?lozr8zQ$JmulR+)vRAzv?Yup9OwfEb4!@c-RyC1rHm2W@dNUu<^4Sc{AO|ts~8`W z`M{I&!mb(?p5)iNZx!a};WuS^=8u4|0}uj6>^|%mw*COdT4^BDD*;DOx|u`kv?KP7 z)3YPTDa0e4-Ir}345G_z05mhQlO#W$(<56wc@~sD@E1YpDSw{B)&~S1xR)+7XY6nP zpx}e2fOlJ?EP&6AR;H3N2A{X!5=_EJ_QIkK%WP_mBlaO8IYnWU`<;{%Y+5;Z5LEEQ zGmitEL=tjESZW=q-_+$y{>THm1RL|tfjjKZCLPh)t+ORSl0!3Fh*)n)4XE~}!rJ{o zrLPUkJr~6+Mfyb@RD+rV3qSvPp_~*~ zlyUj5zrg-LU=oa@guLrQ|5W}vjE{pSs{T%QntqMP=7nF0 z|6Nv%Xd~`Drv-e0u(RR%ukuy6xhP*{NAF}aD}_pn9_QZ?>E?fPgW{T|=eGKYm;DLM z8yGK5Vd6yg`E$R*DfL{ha&{GnJ%uydggg8{vnGb!77LGyV3*LB1P?#Hfm=021^X?M z{LtN_{uJg*zKy2>=an+%=#tf%bMc8mchFj%;Yq>EsCX9hYq1bgyc@j`e!jZ@NFR9S zw~70kzk8fNLeX>~JjQn$R02~Y(hk0kJiE5bY#+AWojM!bcB5~gM$ooyl zaA)#ME8QqJ{NdRg;Jab&>#H!&jxI*=$Bs)C-~O@VD?yibM%tl~yF+Mi+xPW-$9ja{ z__+Fy6Lfo-#?d;q?jMy{ophCZ&pCqJgx4}kChqHd?q3W=aPw|JM#T~2-+=VG++UQX z^FA~FN z-lddJN7b&;kS*@5)BT?3!n4Xjhxw=~L+(3tmr6hp>9?YIIqCSd7&G>OpXZ0Igf23= zu)hRNk%zAKI;Sr=r9mFn0B5EId9|C|_=Wr$epW~RU;#h-Is=d7pBcvqeWGaoBYsbh z#H8@y|HVAW>d)&s4?V2+jHgpQ)JeT^u450V?z{8WhOMtNNe^)ZvL>sS-(YQg(C~}- z`-0CJ$1hr6aG`%lxso=;9`Z=v$iwU4%c-CQUU9yuF%Ml9m9g*3`q#BDl95D;KGsrR z(H}iM`-TEN-?@>hQU{7{+WG*^M;nyQ-|O}9CL5t$pa5XB3eoG153tdSo!7_jHH5DK zS3odJl|KH4iKfji1F*O%xQuV25)1*QiAz2H{=%RutKK)n^J(>ZV*FfObuOyfXRJKJ zYHu@ktJR^0l)y@2URO?q+NCRRpmR;I=oT?C-kW%5x>1pPkJ02A33R*X{fkguM>cpB zxo}~`%@>r`h4}6)Zp{gHKX=^tg=Ec;sB)9SSn|j->|cN3wf9GCl4n1K|1qt zv_H2XgxL5?%scY>jSnjf>j{fCv2&j zQbY82^oJgWr*Smk{5O4p^##aCB@};bL+rm1%+au{>_MSy^_RW|3yYKYB>8!c^3xYN zQb)bp5>EFY?U&E>$NO0$zDxa9`xr4>wd@lg42f-Opo@P--|~nx(7?;-)`~&eRe$&{ z>-o-K7}dWCC{WZ|c)t3q6eZrTzUZ5pu|M_|+#P-2L!!DmE5(za$<$z|uKJ5V_H~VF zwy#cCUCDpw*Xb$#8IxM6YV^&u z%q8IXWt*chBKR<^?+q#KYO9-nM$hscY#5@_u8R(j)2CSaSs?QBTws=m5d|9Bt?a1& zC2H{sQbz6JYf+VFrH0%!d~$BO`ifjy@e%s3DLtW!l+W5oJM>AfRePqPNW+kzM)E8s zw`TM@%Tn8yl(elvp#viZc4q9m!9E29J{0uE;G_`p=V+9qh897vdi)v$x#*QCG>m_IP6(R-egVa3nk_2>0H_J`Ti9j=$BmI>@)SimK)F$*K&uM zKp~zq=>BYPH3IUPAk!FGyyyAx$OEf{PaH2TUS_ z=BM~QFF!C>C7!K$SXTj8@lk+vfO+!QG;y$`n6ss+`s9$ z^X^o!OzOpg#GHzu(`QL%yTJCG9w;I>KIzUhO_e1p2yv|y*xf{i(Z(Sno*no;yH)4 zpa~dqyU6V^jiMg=`_ zsGv&2f)L~Cab3~*U^`qsuPa#Hk|mx|3Ebj-V?@`n{TB3(!OqlXBLWDRJ%eue@p=EE z?Kcc%Inc9&l_cvIzLY7?2$Rztt$#*k8wSC^-w7kZ<&DiRSIpn}cJ**z_hfoz47DWv z+qA_r<>T#QT>Zbv-?H`&nf$Nc-|_(0>lv%AxWCxGd_De_Z{)ncWdpy)a(BSrGAN|U zp-H?}f6H%aZ`=NsgVv}=^0%~Ulk*ujOCcTmtp^JHEeP2PS4YW&zh%)Qd|2M! za;~!EZ&}-&1m2GNTO#}X_4`-sO522g#okN(E5DnR^sm&P%h0#)Upf8uynkh3oh&_b z$&~f4Si8gdS8}>|7^`QzzcIJizw$Wuj28M=?o*2VD^~3qp~v?9D^Js1Fs_|$w)5M^ zyx_FpH}bFS;)ksS8Joram5Te4Q<%_~#OjCKKw16E_*v4Pa%|xF-|1hO`ax+)>Q*=1 z!pow?NOO7iB-e82JOc@1IHdm%11|5Ww%8 zX#f=zL=8kDFAWRV1zsACr%0^E_PDdo(`u}Ojr!aNcur?IZH=LBG^b6ednv>l7Rj68 z*H@n@T%*Kuvw43J7=RZ7$Lp&{9w3iPxK=#BzIwKj?Fz(bef1A)Cy3Wq+Y4*=&YNrE z20Ee!e8&B6QyYo()kY!S&VejW;^)p`C8G%D;%7|8HMkee+i}?p`B|TLD zYboizeGg$lFyr06rYeF9%E#klPds0JP>O%vpDR?z;{8eI0BGsVIminV!+pzzKO7F% zHzULP6_Sv}5A9bV*sg&YBAtC9GqSU5SoRqtK4~bO898o7=7Zy^W@OGBSL1@dcurw+ zLI3mmM_5zHrs}A#*0*oI8n#{@x7P@fOh-Di%EwqO_nQ$~7oaTCttPtF!i^#4@S4ur z%?@^ciTIoR5k7ufp(e}R?YhVq{}Zlc_ZZL9vpZAuO1P);yWPvmXJnp42?JBGIV%|H z%)@RAdH6r@i89VEcj0oq&d9b}Z?c|#vkgtG4z+;$H2{i%%&toVgYoIi<>PpoH?B4f zTmbHjaaDp6wdH`=G7gtvK`Ye;_i?u}gVs)$JNVt!UG5X1F)F2#jXB-7aEmpruib6m zA}g#S#EV6o%ky^&0n>v9;QA(nsy?hw>4DDfQC7~)R}Hd)pXf|V$MXEHz<>ESfxM8v z=k>{KY7(HV=WjfJiHS{w&_t&W8viC8o&o&2w7Ld@;dM8@UIT*Ff?(7!dpw@_dieaL zLL?KEYi9u9x*33ad}Pl=>t~n@1^CvyVF7&_u7B+yKIq0qoD7JLLmLd!3P8Jj>qq^{ zpw;0X6OYtg)(L8$qjYvQon1(0b&Tyo05F@*79fH8h_E?R6tWkjVlhDSmoV?m>!Q63 z%n^6NbJxlyx5qcF(LQ&=dZs8TZzK9yAr3M8kd`r|73ogHQc6Nluo+#sqCvtyc3q`k^XRW||I&f}l9qcxRkYPjkizK@cT%n2*)q<}rcXb&`SCl> z&7@CPL3>~H_?26If}MxF64)UI)pQD&H2|~5I$*~H2bdWhP7~eO+$KThzH7ir7z358 zL1?!_XX?wg=|MQZuk~Kmz!$mn*|oj_ZrD0@I#_NX_p7h6zug{`OjrXKcQfp8i*QU+ zEWj={QfgGL41!zMm8TaoQ6u}ddBa>lP)Y{bQOD^Pc~b|5;I=E6A*Lj;$jz-4ovC~2 z9;L_z@7?WOP2ZX74ry(cw%*co$E?Z$R?0nZX+0qgFq8Ik-ts}tqP2Q=x25%kayd&A z|H0)H(rPU2dzR)xTCJsh#nLu}v^q;uJT;!FkOunG#<`aEqEC}IX!NubHE`~dT{E8x z>fJ8@BWORjtb716gFuGQQbPf)UOl(@t`Wkd!Vi-B%@%E_LNkeF7^-2gXhxn(fZn-3 zuB@2%F@V)&f_5z7;X=ws#~QDcjkdU#frI~+-aX! z+3R^8I65%>{^cVD8xsJW92H3d|JA(2S95sopQFO!%gyWS=*S0NvRbF8y+`&=^uSUc z9v^yOZ{t;08Q51ZzF)H=^UMbRd(Th02&0@!cbaIfiE*{N-4I$D;_40?H%Ek>_o`2s zxX&)&Q0wY8%UG^_H##&v_Sjdfk1dwBN=4iRUz3_N=yogdkg=iqxxS?TV7cYZ4NZ^z z=!;g_EMG(=-QVl|cLsT7xF_BjYO=TbHTH>>9p|5|&RYMhX58-n**aI@pKTB?=JYLN zzmg90|3Hw5C&+;M00sIVFzog-czHCHpNbwn5Ir0hJ)nS;Ot*D)i8Z&{y83zlY+b#; zKU-Hn>YuHvjsDrXI^CY>>Vv?ee@Zl^eiB=l#1;n9;ZAy2fK9ED2^Y5C_=-=N`0<@> z5-TiYx$<559X@Yt|MLb!=i#m*?lYk#gS#@^r$g!0_SSKSePU&Q>YuI7HhZQk2W#R! z7{Owj(6I_Xm8kHHM1`kD6+TRl`gMVKzxZz+qt``mhHTPI-5q;`L0|C(8+6(a+VW0& zdl>YK&)Ep-EpL^IxJwW7c{XTexcQ;9U83dIV&OpuR`xdkY<1qm^S}wwSj!=RRkk?s z`GUmfpV8+RiufizGRitUWa7VZnOmeRGR8jRGx{uJmGa$Phx*>GR-!w2KfP7&7WE>* zY%G6g-=KZ@%4&@R9sPM81};Mj=;FkFv;wJwvtd85<%pktoO)3ma!aRIv6Mj!rA~rv z_)AF2^>bRG{%>h`2zLCJ8Lj+=OQ#=}2V~dzpbM#gSRu}QZ*?9EQ2L0EJ`!bQa_z+*U{LMu ziwXp=7|RZK$rp6$wyuEBxrcudoxt7Y&e~7z8(l5c?LNS>*J1pHxD6Sn`~Oa%nt_>C zV|}8=afupR5;g9gsIj7ajs2=d+vdyNaV-B?>G(55$SJfR^#$z`{aLzve&AQ>$jo@) zyBLF0uu+G56{3j-zUbHafq!z}{J{GuQ)b{#kQ@f?_apckZ%Wkou0)M{CTjdv`5K$l zvBH5T{Zm0FVeLVC3V!(q!^ffO+oqqzP4<_(9ZukPL$b-y;wq|tSHZ3TJASjD%c12D~wAWkNQrgkYK^M2Il7H57M| z6c4nLhwr9Yug`b53+}}LHbiT2i(o8v-y{S$-=2kNE8M?tljBIxY;%vkS@W=-=aufG zlraMqY_weq{(`ffhRk!0TfoF0w9UIYS4VTQt=rvO)CY61pE-4QtW|eqmS3*ARARHK z8Yu3k|5}?Ee7salU(p!~3mGoPilUzgJ!QxkF`Olk{bY+S{usK;k5JG1GC+kA@vKc2 z!Y{_6oDs@V@T!ki4B^bjz6;bet3!M9y(b}kkJX3T0A$WU=6DiZ;ZBuc3Xpl=R$;4$ z%x!P-URIIyWGjQ2FUAG4nUQ&#Eiet4!G_Gg-4@|2U|M2c4TF?_Y+W@Ah^U(bhjFSY zT+v?wdY!r#9kP&wVTV~JzR&_21JpFOBWaw(_OCq0;!|A!vCs5f(4tv9&<75`T_x(bV3@UNv4Y%Ym^=5L=8dPfh+ayYCkz|JC!_V{SV-68f2 za6swyUnPJ62Vb`LmaR)A(eRH^Y-t6M?P+?FlXYQlo}#8z-@2B+F1MEuH@WktFrKU) zF!cboK04+A+u+ouzRGDWsV!5Hfzw(V7&3W^&E(4hD%n4y*PmQnZkt`Shl%B-kRxo=j`0eJ`F<#rBG5v*Cx3;7< z!F&7MaTS7t<&}*ekXGZ&FBca2cb9?@_GdI*COYE&&*f%7qR3KJo5583GroH{$p!l} zu2xFCKLg|g%zoPkOntch881IC+}TF_0E#E|Fp=fs2Xa48B6(^201TVyEa2Bs{71ol zGpwrN_GdJ2n3B$pdh21>+=f$d?}Z6JaL%23O40`$y+{7v=soiN=G>R?aOeHL(R-f+ zhT-%jmjCzo{akx@@%xADJ@WJB+)4Hx`FL~gNPAEEcRz8cIv@LY?*nK+WlB=i=kdEp z-iQ{*$I49ceiT_Vcv=U+6lwIo(W~Eh7{}W!+R$br8}-;B2@r~=3&6-EljM0}))p4s zqp1SGh7x{x&)*b(kCli)9ZD>au*;ek*!|i{#K89@Qca*{lY5kYB_<-|wUF21{$zQ5 z{A-gE@|Kae%+8n0JLGdA4|1Hp!p@^4Ftq5qHuBosLQ;tqEy`O-9`e-k;z{Zxl(fjcB>?A&n_%GdLTZ{zDdQ%nb zgo0OSQTm|HLeuX){E8jJH>QN77H#<?leS(&L0=Ola)i5YL+x^|jdUy<+zBHoP?S3B-gVkC{D4E8T3e&MLP?xi!kI zQEtub!6^P2vor9Ih1;wv)r}>SsmeBN&ZI|%3W;#mliHk8qbD^yrB+V_S&x}gSH^zI z^QS_7B;Ex#Oz^KAdq-F&dEv0~P4!c-AV2x;!x2y{A!uF&nRr>?~xmlXjk{U^+j4i69SvZvLwL6PvaQK$|R=$@ZE`^l+RSmpa z*Z{tH5HB6Kv5bkdHhjjFzL`4T%y|8@uGX9TfpQRB`DPAaZ>O4hSk2s8)C^syaE}i~ zLqV>EW-O!DH>0%*Ml;Dbqc?ZFZ)Qclncpt(&HPQxTv*f$Y^=h4A#Mf{8Je+-n^}?q zXj6PMT1;UydUFpc2XUHjW)u{o(LADN#uqh%3$w!Q88?F%3(Z)@dwnxAeKS&sX-02u zu5V^#zM1Q<_02r0W*+ypWT>s`clc5(+)p<}Kx>biv5Y5Qw$Ys9n=$`l*!s4MZzgeS z%Tb}3$JESsiki_uYAzKw(-Ajg8JGKJ=K5w#4QjOmUfuVUL%dRcG~L(u(e$!O^shj= zLLYT5sp1Fy5v9(jnA#0j`fi0-ta!h z5#m2P6mN(nQ{fK$zNAyHGySYE-Y_{n;wX#?Uj81%O=Kt44u~6HIr$G9+Pm{>*_4A z*VTzaf`~YR=K;Q7;=k}xB)i1E$Sg_gi`G%ks_x7ZWBr{=#QLS!!2-plg|#8aIYJhJdmC-AX6c2)W75Z4g z&Nx8o(%I3!-%q2A&GUKyg*7J-7;~hP_0;Bt?ZBG~UZdJ>p~C|5uIFi@d?3P&Ohyu2 zO6l31p?Fp!{Jj2?kMdR%quI73XO+7f+rGb3(N?JzG_qxq5^+riluO6kkC$ObO zc&+jy0Nv+ZO_OzXO0hf%^rh8^KDV32DX_8RPUNA5m~qe~uMb?#$Jk*5`XzzhSJ1-1 zftEYp8k@vy4G|Fq4b9~*dY)P9d_L98xQ;P&GEQnybHCl!z$>zi;hQ93^H(7)*!!n% zl38(iPY+GPx9q5E_DRsg>MF2;IatP#?e-`S^?@U`CF_QY34gQUeT0rKGm+`_&#Wn) zOx7R!2zT54A?}>?1t&o2%hIi5ZzVm%ow|R0#_Hn4JhGbCS7~03MmcC%tNqs-Q#Vu+ zF1QOL?Q&0CuzBmowK~}SehuCloy+uGhXyF&=HCA-qPumX&Qk$rbC&wB8>lqrV(Zuo zefmnJx2{sQtKQA$tyZG@+{>?o$Q9f0?-!{Hx^OmK=wGHa?M$M`z!8P7A|L5T(JHsE zz51HCTW%-+td6@)-yyc^Sk*kneR_}5TUROD zJ+?~#m=fKTf0qH+cA;UPRx)b(Y?Z#m1#3L3SFWGu{=?81(!#W@fMt5-4RW?Kd#?}gba(bLn?cxE&kQRhblkUo2Hs@N=twW> zY!f#4fCKkvjX-VVnOoG9-S$dQiTkzWwl6OR_GW{2EfQD}C!y9*-4<1c+XF}-x^n3K zIl45SJ|O8NVZ@=MZ<;&DYsNB5CMmylm44hIsy(~PKFKcECu;LcmP$BWb7$J!rI+TR z%1dn;J#dU(bOs|ms+Uk)XJ6zef;_8+p6^ zByie&>{}!hatW$iMs@uY=%6VUa~OLx^Oz#CKCfPyy1EbpY)w5z6;mc66s)w1HRtVQ z-?XZ>2*b2CAHGpb1qepS^5PZ)2B2&m{fE<~rL`z!diF@DR7!_C8NUS3qJZtdnQ;Gv zyW9%~aMNrUSy~g9wbJSAa(io?c){Ng2(QcuEJQkxTdfnf_9+5|Ke6R|%6bRglm0Sl zY=QnV_nW|P(YhvJ<@J}Ww?X$}U3feCNEv&pz@7rd&hh@Q=Cx@}{@qPtqhUi;iNCb0 zzMs@@%CwiXceee#G=Own`sg)8k!2UurL#M4omofxcJqR|ih0E1grxCIqqnVMdtw%% zynD|`lw&9c&7Fk+L~!lHLP)lcGQNYD5V&o-``lkehKdqmm&Bd!YZrQ56484UDxV~> za@|sVMm%)8_n*6YD@&Y2tbmh)>Fn5Zti3(b2i|Ql{`Y)?M&v=Xa{vigT4#HZ^k5ZD zjVh|5B6`r_8oypRebXX)ebI(lQgXASUfm-xq_F+V<6L$@l^fs$A#joj18LX0wpWCv ztL(M)y759u#(TR`TTOpuq;8*uhL3(PnQI^ut!7mJDaI!}CN6kE^^CrGG;JSEJm})X z5}9XM<^n{_#AOt4$I*uY1^!hp+1ZMP?up)8)UoVp`)Qq+y%%!WKp5eGwjzw`*9sEd z61vgq-X9s#!~3pb8A%HobU~a9T(7UVzh*0yy<|8JybP_de#~ zw0g*f$)eWWFN72^Ed-1*+}{MlRx9N000{K6-F*od_ur#>3x+vI22?V|3ZJgR4Q5*< z=C;lE*?w9l9)Aygu8I0QVgTV9P3!?=QO`2>+($$ADy(~~`rYyQ!VW9L9ppP~&u{b{ zUgrL+!HRF@C&lVqO?v;$SZY$ABcLxBdS&Z+lMPsp=TRp=pVp7*?+Ym=?GgY9PVNh* z>1$uUlDwG)PP2^N^;@O!`AWzeyPm0`$RuAxCEagA5jB8b6CgAbMSb-gUreRlH>?;# zh)PJ6w-PS%q#CjA>kIcLIuvBCFRgn5rja$2IsA=`D*>+XH zymiW0e%gebIc;y)&}V>Y9sA<_hWaZ>WKfou+wAjJE784egWj|eA~A#gyU5Z@rj!}y z%3g@LPexF(VCm#rGq-UfThzImc<%p^K4dSM;Q5t{jG<(f~zt3+BJbZr+P>*UIQCQ}kz#8Di)Nqdb zBq>IiFx-en7{1?bG{=hD2ZEhz%0wzmt1S=|u;?m*{-2KqDtKeJVc(#q0?WJIyaLQ- zol1WB`9KprzKAcm-0~_S9YlHVc~^#B22L%c0l8Xc(nqg{l#+zibR+$b+F#+H)vWun zf3{v~jQy8;+%QO*vF^7K*;Rw{B$^DBvQ0LRZ?Blb+)A;FO}qn8yvE(9#wM;csXqE( z-fq`flkQ3y5c$XR;GP>aeP_hLDPi`!)2v%49f5cjdZcXyp#MFB-y?ivRrq4dl_<6K zS7(SKbR&)512FQRQf0h())F-|HD6huD!V#V7S=qMIBR;f@(@e*);e*;9jGpizIt%z zI!{iX?f?9fraVm%mVEI!Yq4I>m-uJnIiJ?E?SL75s`mQjz0S9{04fe>S+q{tyv%|? z@*hrAdvK!K{S(#hY1R6L(?hRP>~0gZR%(x(aagq^&lJu1sg!jpIv!UnL!YK(@%QJQ24uF2Qc*xZBk(x7*<} z@+9zjbo82|m-Lz=x_@X%rsWB%l+X{T;$K!>d5$XMt52E7(!gF!%jbXv6+NDLINue5oxRbw1Ea@vFeNPo!#=(UIw1Hk80hg zq&gXlVt-66*vkaX21vbD=Ep_97*6857TFBGd@p|_)JZaX6 z=7p|e{_!4+cQIP;a3>zqOQDIQ?DqGuS8P#MuY1IbXd%|l5&H$N18jt}A@sRAhR92w z0KT|i=LfPua-Cm3qX#|ilT2v7^YMC=$0y+uQ4aq85Fs@)+qY$g3Ru^1P`0dYR7`j$`1mza~06JBrsV7mwIZ zzc}{ff;I-;&Okcc2qQclPB5DV@Mqn7z6ZBGdTsSp%QW*As+`KLPd&u5FEI5gD{x62 zi8QRe#@Z(LtQ)Tk1e9j-5&PJh$W6~S;%_xPO0C?;NAnJXcjnktM^8R!jsELPgh3v- zj#^kg_WO$6(R56Tg|3Wx)@Ai}xSsx`4%=$||Ht0Dz}Hz6|NjXz5GW-PDO5lS7qwi} z7N`VDA*Do5rIiX)icmq(QUR4q163@frp25dB2`4HCvZ(u((|Ec!{VjtK$}BR7gW4zr(fwTLeI+1k(OOm4UZ+oKF$Slpy`o$E^kFU{Z3J3!TU`WzgpHfz)1qQBdk;TeR%8ga(kAJ4F4{v6;_zG3k?e@H!-*yU6 zq&>K>FSy80zH?8ip#MVr!H;oD;Zx@szA!+yyW%m!)t)N?1XgR|-s2qhXSg3)ah!55zM3udZWVpFA?K@5D!iJ$ zgFXno#ZPVSTIV2d%{rna&B$y{v>TVsEhU6Dt~``KuwNxOXgI7XcHdL#drmYis?WjI z*mu3So;#cx_?kd;m`9XE#G{vs05@ShPrTvnkAOaE(MIv#M~pQ9zqozat^@E7Y)N2; z{Q)gf@x9hR11TEZe~`e>mNtAJMdL3;zoFNIUvPi!Nn3)89RrY_e`r7ZvARVkFJ!Ye zk%zeTnWnOfnS%y%+D!H`n`>p8G$G}5JNYb-KyJ~)RH5ZI#KOh4SyBght#hsZxno&v zHzb(TfyeSTRp2#DhnuoW3Z6YLsGBH1CZ1v}8|HM9-8x@`z^9J>v!&1a2p~G$Zvp?? zQi3mAXW_3Pp;`6G7z2;j{t4`{wQUtYSnMw|8?PF+1yjFCvD5uk`m7;e2@}^NFQh7d z1_1Lyl=b!^Py0lyuf6qQKC_nFo8bcj?Z;t?qf1Q{nG=C#IbZFe*GIK^7>o47Ju6vc>_Um7*IKG^R+H1J<;yfbI)EV<%vCi;f=~x1453qRB zrXkblaGCjn@L1<2qlsEx=dO9eYPL#SUak22Vz)ar(4>9yYQf@v9R@nX_WovR$*WwV zq4dtoZuexi>ZEQtQ#1Ys*-Vq)J$?Z_fQ$KC>8|+;U*V(M?3XYBh5lif z(xa{gsw#>=&$rogyZeFiar}z~cT6X%XX(d(9%nsES#=%xVOH|nLCMcq4VsZQx=$;O zN!;I6Ea2q5X_T;nKQHmn`u0d-vy;K`*nHH=dn^R+Q2VCC0@u0i3`3j(i($BO#w1>C zvYdXORfYK-tw2t@hoo@jZECmNIb#g4g-9&$5$|)C<{?*nF>20V!MWeLNt3y_d`sG& zGyOcV5pmOu?rA~yAUn9ll%rbc*JgMA10X{Pwzo8yB0T?0FoqfEEK}jCpRFu9vC_Lm ze#I-}l#$Zy-jrpbK~7gLrlsDHYIV=P5{zA@t;fS6en)fOy+FD*9>Vh&^6q#I6JV7- z%L!{W<)y#|&2D!UuqS0%7vlLc)#J?zS-&!7>+Hie_X>SYaFd(9W1Se;3&>xuhT9+o zY%~@8Ii&{IkGF?)zek6rX2mTJxt0?>egDdjK421uR36o;*WBb?J@9+iq+-3Q7 zZ>8p>1^pM(?^d{uaS3wE+)Ii-+BAD(msuOPHyU4~F9UnyCwjI6L)W>ye_pS>(er{= z520|j{Nj?q*&B-ipRzYvJsuqrF7pI?fW2`8IYN8m@Mp-8wl{9%^Wg1`(JyYu-q@e7 z66ou*H#XOllg9o>?TtIIfd*%9JOjGL?2Qv`9dDD+G<)L+Uvt9V_#HJA+8ei=HAs8o zGEq~Jdh6WQK=$^=$$qDPY;RoBM=q3AF?-`u=$*1Rj#g>owtNwLV|&(A#Yf*#Hz_nR zVQ(~An%D3@vFCPotbPaD8!x=9;o!4=MpkhbJ#B9cH^76iH}3lC zJ8f^+B7VZ&_%V?*Hijd6qfN0jvAxmDYiMsgj&&c}8)pG2v^VM?YItx+(%zV3#10Nu zvaPy#_h*4eWsN2-DQR!awV8vrH|kVRF?)l1nkl?tdn3?KHvcwX@8#vfTDr;4M-%gN zzO&ys{ayNDBnqh06t--JhB^JEbz5s&5Y?CTak!Z51$+Swy``DmI8v49hhe5gW}G4U zUfbViP25&JpOxW3{;{?0-1oqRsE%$o1P16GXDsADRWy9W-Y`O1{KkpR`erNV-m>sD zt_C+R>QR{;D1)3bY0+b|lX<|Dv{;kL;uu(Cvy+SAt#EeIk=bo=W~;xrZLr4s&J~Q` zg{INq>U~CK*svYd`;67QO_6%HFH-MEPdB=CnQCpS>vFH+u=e5vN_!HWBd4fQZyDWS z3pajUCAK&Q^so6(ecu<_FUBA4^e3oi1OAPjtyco}DRQ2b`FH6aZ~9pMv3((12eSM! zG}mYcuL_$rwd85M{wb0s zWk)eaUCFHNl}U?Ga0;YocPtgFZ>nq+uZTU&_%C;-`b?pG@byY25o649X13Xia|6&F1u zhUTI_+DuMXG1%RE&Tc?sUb@0v{5%rN3tszZ=2UHK-@|;gb{}agyY24x9Loeo7z_HN z9-THgrwgYRHVA;3Wt}NlU@07qc-k7!32tQ9aeymWpOSPO0fbJ9xA03J8^o?O#P^2~ zKaha<%2OdkijS>rsY3vJ0KLntX}*$Md#MB~K^FtWRbQ)At2(UGQ0V=cCyEl=5b$lI z^O=T&N@g7-bQe>`8@pX@DkMesaawLAwUV{k9WE+k|Hi&~MYoyxThS*-$Cc z!fK8AQ#_{c5l&>$zsYUh(E=g-$JdpqqFD81gB2ofbI3;pd6wW`z%xmZr?pyl1 z&`kM9i_Yhkh!S3?MT^nF_(_gWAI|~3y4_iVY)y>D=I2RDkIgeIlOLP)9+hxx)>EU+ z=L+Gog2P~k6p9xS9kTKXaGyEP=GpY|^1OvR#zT;PeI=BS2n5uJ1~6N<-F|9d8^S~X z?aIpExn=Hawndi7-QpFS-+@t3;%-w)I3*0^ZPLD2pL{eIK(YLN@-P&ozwe*(JyBBf z*2~v^M(r9{N`s4Lu*~+7Y)#)s1@qM^`rDdo+w18THM)+ID2+s&ZoV&x7Kw$^;Pg+Q z#$x*XMDuqI(!Vpwj7C;|@Mn+ur$mVN?;J}yR(Z<5GfHhO;@?Tpe;`EouhM0{w) z2}zv1Jn*tGUXKdf=Mj?4CK!K3ESNZpT|(h_E@;n&%9m%dL)i(*&xFwCN{+a2JKhn0`gS7wO##TLtN3U*NIhwlM=%AZ%F`T{S= zA7rfz@aMe+cA-D-YEu!Z^}}_19=t#A3!tA^KRo;;(HCj&*AGuo`K68^lP}Y*h^?0{IdVToc^VhPFnxJ=*zkPqCzpFn+GAKIf56t*Y^4H!>$OPmK{IwUD%}~r= zdn``t_4#YpKr~Z}vo#HVXZ*Df0khCw``B@@HVFN-CqDkp`fE=tQty|F)O*3y0)OoU z3i{bUT~O$+-GRCEApNyNjbn@XC;a@FGYkUWC@$Z|>Tp0CtHrS%*T~EBg z;O0k#{$Et(VEn(4t*%)yfrMGaL(|GIyfE?D5$M}?h9|}CiK|DmI*ZJu0wX0=D zx4WNX=6M{7@sIL{{I;ghzYRTO{)&A{u(!k~F)6`(2_6f_N1Q+04{&V zyDf|(L;j8NEyf>d{mOaA(O3xU+hFzTPZoe3U5F7Q7sd+< zKWkGD0;b2}zxNd`qk@)Y_yyA-{#)lw#y;k6g{}4x-UH~D$sOpbBau09{mOj$D?AV^ zBrBh$?>F^P#?;U-R@xuNl9F$Q{1Nj~(Emw!mEymUpYUg97C*PSXQ|IV8nRR&{~NxW z$S;2E#QvU*$&d(IW z(T+WVH^{rGlMIovPhsR_fA$aB-x7@dg7SgQTkRG}D6UWct(6H>pg&C>qX%+2$%{h_ zEo5FQA@Zknfg7!wih7*fPpI91^Oj|ANB9)T_t3x6uu=nb5ugUFe@)dm%GNg9Of<3n zHQmw^>tEkeLc#i1hh-Yv`q%ZZ()@NhN?=$V8?gR$dLVxr>{pX({Rz1N>t726D_sBT zz&uhQR$>vVM&Fs44u1XX&;-O++CzvNT>o1Biu$u~{p)U}TGjNNH3FGf+p@v+uO}(v zokLx2{>yq!t$&?OlBOE5Y&sLUvkB{8qlJ?M4gV&$6|8@4AAEe<>tE+b!mzk~c(0hH zfd7lxZ+k@f28`cg@&f7br16wEC0ZYQfTXl7;`fjF^|5{xh}W*`c^#-k{j5+PrsU_nx59=+>E-S9zJd59%OfYt-5;Yo zk-iRXZZBAZ)qmapXNph@^WCnWS59B@4Cjc&6t%)_VQG7{O0w9dhl8-EH?E&<{#!~v z709zfdWCKA2-s5Gde$Fb{F^3G=C2Rd9}m&A>Yee|`~Daj(K_b;Li`iaeopdl zk?-Mn>@jm2LGm5lq803x3^z|UEU9F@T~m8}Ysh1N1Craus`z4WIELC(vw~WO-RFT#pKXoOt1|$#nHR~LKm?GX@2i^$a0n7Yf3=PU% zEm+YOP>=9H|7NlIbTB?QC@(-F8ZR+D)9v}c^~mHGAI z3piUXbNZbAQGRjwFM17?%{=(6h`mu{Ji&Ttdw(P2Px({xfp;_ik$xB@?WKYIjwmt_ zoSJ|6@vv4ZIxU}*<;|WcoS(kU_NM0JR8ZsNKadj*9JKZ+HK={UZ1q;Ay`f&e{KsRX ze^OiI6^X`c5?^=4M(p8Y{k@U?3i&;fuOD6u&Hg9I*YDcRHfj0#{GxwPz8)@E?}~g) z^;ePp7(nko{wqf9zpBqZppGxlXWzX1-=p_mUymCV%BcU0J`3pGk2=+uM?Dj3w@0)F z7;E3e{x;LU?v4i9R%ZS-v%scP7PbDJ$09OZuca%g=W}dTjr$0`N0FlKN!Nd=mKMEG zDvZZW@yFQ9sY|D%{U9IC=8$!T_H?C}!T6KMUM<{MU;Qq4L~<{xqR{{5cK(s_>9mAs zeOLT96M)#Ib&IfPn)%-4gPwHA0*;}k=`Av04x2(;eO^XJoXXWLiD zlAJ5sn!7~(+I`+Vu#n0;|7^vvD1BDU9YID5+ysZ22sX{Avr}IKWQ!Zgw?0}IrsUlY z29{np@8ID65m2RH6pODlVEsks2G&62@Z3OKAg=NYAakoECM_@LLE8}_{OY}F*k0I# z6l#;u^(o)+Dfu|%pRZ`StZ@w~N%JkxFM)o@l+{=a0-m<)+~&Bjf<7tiKU$SLXrh#D z%#b|^u1I{l$@c^!s6Rt_5!)j=qsQjYp4PCscuh8=^?!l>DkzT^ROeyWmAQ`@&eI?a z@a{7EhT}ISZr6Q=0DZqK7O_^OkB*sgXE`NZ7hSCRQy^4f7{7is=EHv!OAN2SS>Lk1i5>DP4rZ;B3J{S;y$$Qerz z@81pkUu5KTL+h@DzShYVi$q$kQ&EyGETb`=+iS!}uu9qdR*0Re=3vOraUzPl z?|@QT!StN7vpHUoPjmXY8EXoeUC)8aDnV5Nv0KI5NBQZ5}f<$Nz&p%E&?JHPf`Y2W>g(XBM0)h#pmAa64-z5Zn({lTt8 zj=3%;Sjqgd`zp!pWwA?eS8(05fL7c%o`&(K3?s?Vw^)@dsF~?y33;;PtBf*38rBS{ z(@8X1^BCcF&Z)xlpW6oI?F!AtrT)Tdv%al?H-8}DWJB_ zE_YXdf9*Q@5JHtmz06&zAtC7>oXoHYDi@t^srrE+%X;t zo~zv__1v%o8-lZ#lzE>p*GCe$c1z?MPp&|qLbZPP&x_Wsi{xp_9w>(Y6t4lXPN?wz z)=y0;|F2p<-Qjiyp>5JAo~+eUJsyt+AQ<;y{f{~2VZTm`BIubmcM}bq5U1j-iYL~<_E-2jbe<%eXh-t zi`o7y72$E<6eVpk?=jVwLwnY_b)DJTHyY-=Q8KGMSNjH2m%gD2sUv;|%u$J&k&Q~K zvZOw!qCV6Wq&z-ZPfk@*a1Q&|tE}d5>3b?v8Ta^?OH1z1^@gsDiEUqrc0=kgxmaEL z^}6W%*gPzx#mzjhs7}y3skPHRy!l%`L~;j1VuvQ=6O+y>?RQxp)*z@Y3{v;qSEN`* zw{*A@FOxapuc&PP_1bk48xD=mnQgJA=teSkEuZ@6zcJ7JnzFg!(|;upoVG|7J7<<7 zQf-I&#Y)gQvr0&uGs_~P>$y;M(HE0Jpkio5Ka0;nsZN84owSe>i?k_|`;Ps%>Y-4N zPx8wbS7LUPIIpM9!=%C z*(<4gqPR**(0nXWf&7$x$|%sF_M;JeyIq@J!+~xZ!EE5-_!hArH)dZZ@h^zS92a2{ z#X#&$QaT2r+A?Wrtldr0bJ)6K{Cls@05OZ=kG)gwE|2nr{Z~nULksCUiQHA=u^<&h54z23Klv>*wgp>YqZz^cBXDosX#r@qbxKW(}gqh?-M9@65l|OQxW#S_YujfKwjv60;*F;fb3h<@7=p2ta`!~2RLL? z`aY14@|Cmxu>pHGlutor!FafuBUXb7xAgK?vPtt3Z%@r#DLrIFyh)dsWU}60*>3ld zqSUx!drrrstev}=2`-qNETI0F($TBju3H%0a#I_r$X_FUh)>Ga)`NAuHj;h{hZL+3 zxQ?Vqpo+CtgAg8;TUPrVPCAaLX!2*}-Ul0q{Vc_9YgsC|;U%u!>f^r}rj#V#nBm-L1e;!T zrDxM2fbEs_Cj(k1R_A^?8xl=CsC(9M;5IB_PSNe^Y1yQM*4Dk$SJL~ZWajA$Cm!@f zkdsd7cH4o^q=R0yoEOD8xydqsAK?A`Zro%>Te$VBT;)DbIof0`*l$bRyb~#`hT(wo zk+EI9zh?HftagPARo?}Bkx}!Kr4WeHM3=JP86IqPhw+7%HhVeRzbpb+8zIz-D(2;t zUvJskX0kN9qYM(SEp%CnYduF}X@vUVT6-k7T;JjSKqVzZ()R<6XB1xe1vOzzgZ&KC z&n>Gk=iEs&)n5;06b_x+_M#dla2H$ObZw+v?GE&{#Fqs2hwxA09>te?dmEk)%^&RO zOCcBS!0w8*Wik7(h<a32A^D>{kK*YTb%WAkR<$nXo9q5Zq;~%>EksBp>__Y*}JeehpElM#FZ(N`cQPiIe!20uBJlLa64%?t+ zf2F{L`msp=RgxC+gZgfR`WSM={jIqv_t)Tsh|VY0m|5@qcM$U%wQpoVZ)k1vkse6p zg7b;3P39jE`4-ff@N!3scE!)@E8yP(`UUocx3B4y_=t`pV)E&bCUu)css?u~; zQl8m&cjU=Zi1{fYlgoJfj>0JDs#XMA#m#w&dX^9PBe9;o2$Y&(;TA+jD>!3!ASHr( z&HSCHkJeK`w3eP%haJc41^wIxE3~u#yQ2os3&s2tH3qPUqE;xf3Y-0c>(}X6*R#I+it+AX973 zB7a${j0FBL+jQ%znRlerwdgC2WQg$Ag92#*3imr>Bl5v7@H@8xta{I-QcX)ei6eR6rxOFkydgMW;`?~!3CZ=e6Tn!|~Y7TCEI^1^> ztc!S+rTm#~BsF1dI}(md3?uunQ2rIXhyMEv7<7OESlD#E0}MLdE%0Hut?dq;nRPaM z7yP8`E1bG(_akT`Y3EvcD_nCZ_*O^bklS(1rp9WsJ5&!kdq&p=1V+Bi*Kf1WyV_^w z>nq=z64u^CclbFOxk7BZMPx_MU;>_iVcy1ALFBE~68 z6A^fF55MKU#w%+MG`ib;U!Q`bK>iLQ;c?BkFyg}NA@1OrrcTN}H!1tP+CE2xDEu(L zcJ>Eo9KWq67|DkQFs;{?xxRF3>dD@-Q1{csBdu1T=n>lkC4^4AHMe!)=Ny}mb)ngWLUzR(9# zD6jsV{Tc7-{D$btpfe)>Q%XL||8DEgvHte>L3Fd&p>}Y-?k1g=AbBh%*w}dqxiY$$ z{{Ovx3zS1RUkq&PqVuI<>p@%kx-lw}_6U6o+r;y$gunlyD`cd|3bFnzkWUZ-Jr>)m z1^OVcmv-M;{5nefbgCp_JYNXq8)|>f!a#5=LTH$`YORW))FnXvBD*LjDKO|enK-Ev z-9N~)$L~`mw@``BRJ$*{lWA#qClfbb&A-`(fLHIN~J4U*oH_ z1Jye0=<)9XzVJY`A63Rj=tKvqnR}@ji>SrTp^TlQw%X~wD{IeIo`48}Rs=(*`^JLM zi=|`vR&$=cI!1y+lTMw0{2Ll6ml*Py-TSLld=Snck$+|ohq?qh;vhw$ai44bu} zc7-ffGWyI{THT9*F?Mom-QKEg=$4Yc?O~3Un~4=TD=asa1EcBbW$t}QEVFwLS~9EB zd{JA-D}}AOgE!6u+tBSjA+W&=TCo*l({AlSD_&6^l1I@Bv&)S{ zpS569=|RzB{&%2Tei+EJVCM7nqjcwYMV3s%zz3iQ}9 zar;^3TghzdTh&*)Gn7fj1?25)3>MRuxet=eB4giIi&XcGWOV`T304d6c1ggi2OhnQ z*}xyCX6uS_&^;)`Kv4?o+%0sFs=`3f>j?&3fiSw3icwn~7zV}dS$BG=I&}T#9~~)p z>;DdoM{F>@Yv&7SL_zri`BNajtK26Mc)m=e-=uFLvh*Z_dGPlmd}1h0EKKh{{*Qlo z3u7KsfK4V6_aj^bd#vxgtwy-Z#>;HMcwI9F@$=yBDS*q0-H-4kU>2UYb;dTaun5oF zTKPSuU3Ndhw>Pa`i#{26Kf+3Qs<7VIpi$wy4BKvPbko`ez8vmH_?wu~hA~~>sTbdm zFasvBv0l_ZN!kZN*csY_kq9&2wz+yl9xCTrc}C;}_W193i>A}2bwm5x?AHySU;nP1 z-*Lzg@Rz+M5mM~@j_U$fT!Z}vgV~G2Kzc{#*H;NvaDKrYpa0q1v2jj9f-G!!;?e#e6)@kHmQ zH{OyKNuFPSHA&JW^f*%od9%10(T}r=J`uCcH)_4-*DsbTqTTv8xh)pnm>w(KHNnTX zeSXKz8@4xnd`*FTOZ$@;FZfTFL~vs3J+KE0$47Ab#9ZSk^=lNnB7bl?cE!$P(u@`T zvrq-%*p+%-H+}#5>9YsQ>*V@DpRZ(t@h^Xj@}%_n2xK_yBR>s`qKL&CZ7Rq?Q!>oC ze;DiFzjMCEXSMI^-?f)-umc+k``jYb@y2Pf`#J~A*N6BP<;pgeGHc+b`trWk?=IDT55q0=)bOr{l zjmVSq$_sF7;7MA=Gsc%i$UQ1Q#uz^WMuxUmg!F*<_Et!?ps!Ks59|ZBqc!Lf5yIAKYarJNzx~r4>BkvSf_&B7Y-&*NKE^8ukQLGDJ zC&o*V{h7|A|~AuY&XY_r3VtmsjcijQ1P`2H~#q z_6hj*;PLhe3M$fXRq#79_#GAeRtLW|_KUx*p*=$g&&9k_YD%0s&COH|mg8ji6Fw|x zkS5*ptw#F|-rh{TtxdhH-ljbD{!;3#+rKeFv}?1t{POZLxgX+EA?k%vBs@a@(Z=Ne z+x;Hs5B4`!fkjCYY00n9{~7D@CM@}@b;ToA$RTflco2BD?F=m*Nr-g2qtBO)9a~bj z8&NXfKAbRG7O6bc_bomVtU_W^cRv2PXe^aGbqb>>L`4mKDE26TE zJgwwuL;U4=?=%CQ@Bofa>fsJ%^pbXbY8t>dd=8VSV^WTE`SGldKySU*_y3e+WkLUo z{xb((;dBt`cBk~JD^&4hkYc6HwqGU?XwqK#ZhZQCQ8Na3wAY=!xn2;?x>pbo`&X_l zN$rOY{WaiZrzrw^YCUzd(CAhg-G<&=G^xopRcMu<`g!8Wa4jw57c`&)Q+mZ;byIUi zWl6<*CRD>gJ@)SL9X|@(J7=`le4c5ko^qMvXEZ!{=ZtLT_~?D^lNYY@33FQDx>oB4 zn(I!bqGh#@;UjyTzbA+lyBK?dpN0AnDi0efL`aQ0p&ris#37tz)HHne%?M+YlZ)LE zi^sQNNtC#I$=L@KuF%jT(Y^|&5~-rqmwa~W5A4%>e56(0eeLx$y&zK|zpcqMmFfPU zbZ@8icfV{Jzkeb;NPwvUt#=@h*57kiHUcb@wH0O4;!XZK@yW7=Y=O(abKiqjWZx@< zeWc0>Ut}?u$v@dp`1fA|A%eX%e#7q~USSmVnkp};xOw(8_X+Yh)~>cr+v!tK#DANS zt2utgVpleU{me7iAv5c^On?Vbu)+gQYsH<{L^ zFIYzMF}${TB6qnnlyXK0_5rmz0Q*;-7ffCa6M*K?8F-SxIkhd@UUBowuJ$1ve5Ikv zpPd3tz<8&V2{d}#aan8Dmn`_s>3|`(9@JlFvK@QO>FUsFFa|*mDw!hY&9wzVX z&H#l!Bu_*CNg@Bm_NIsES1XMs?mi#~OKhVBiT?V^_eHyQcNV|qu36^K2MTANv2ZM= zugpI=fIgyMK%dFbN80jh%Yk0CW)9^35^Ryz<;P^Czus*iS7bwW}(@U}` z552koo_8}Mdf_r@FUKx8!nl_9sk@n_qBTgpV6t?YSOn&2BBJy+N+2A(;^xkVr*N=# zyPbciV=NnM|4HQOKgrun$E7C=;sVn$TZSMRz&63!XqP+TaZI;uUOBFOYW|oZsAw!B~(#_8*R-8alTQ zbv-qY#=@a)>Zp~umb4a2;a~2M~tUdCpDR{=EQ?(_99zk zd^xOVCt!S;uheJ2ZR`ZV`yD6Ds3_~%A#k5>Y;BhT?{a^AEy$tc6xP}cgInw2I#r{t z+)C37u{nf^h|tVq(C!x5N3?~c$t_}+H;gol&!w~B{&+q$4f={Mz!xnUs=I69-n&UD z$p`JaoqmGC?76x#IBK!iLIU(3qZUpqYIgOD<4S$pk6l0tnWX}i@WgX++s zWZWCPd)zTrhL0}DX{qlg12xH_nC5j|hr97*Ebyd$V!VyYlB35Si3YVMflm|R=s?KAywv9e)J9de)p={ zrKPjBb^BI}jaqA11Kqbi0ssM@}%lTUNV_2E%fd zncRHe3JcRCti1_|P|G1eWI^#EBC_@c0BWY&It0+}0f7B{-~QVAz8xvO$Zbh!*{tm< zzX(#*lick3Z&mWD+Ph0#199;r3;W|}olMhZ+7ps#np}?r zY@XC4`+k*^f1C#9E)$gj+aXc8#bV=qy*1S}x<`B-*~{D9W#gvN?GI_m-r~NgfJ&ir z6MqrF0b!E$-2i0{lt~@eApf!0>S+Dg4vsX1~a=G5K%$CWyDn z_^lRnVjKqwZ=wz??yA}SgV7W2=z8s=%tc=Rx*824zkSl~0Oq;XU2D&}*0jy-19N!i|s*}Ur_QInjW(}0BGw&>IP?WSuOw0F6G+!J(Gr@KH?JiG0l zaIz>s3i=>Hej>Q;L_Z1aa6fuM7O?5-&>rogQ9bkzV?0xij-#KZ!OjSq=d#{p^yh17 zu=bPAcYKSm%jIZRM!Rg(0rt#wDq3JK7TCineXeM>HW0~YvQyzj)V0>dWb~cYBl<1l zxx;B{Xq1#11e}0ctPC~;EkcZ*YM&e8jL6o?YE=FqfqsyZE z&_*Tv(JA~b;vt2+Y!N`^T`QNxS||n$xW=A^H0LGJ0B`+wxyNv4)7QTLGueNr0UNVV z!usc~Jeh&&cgXd~EuOt;q|xKDQTEeR&CjIld~MIlw9j{B86wtdy0+Xte7Pl)yIm#R z7P{6JHP~b#7(@Em2aLyZmq`FaU_aOV*{4moWanp;n!8CqTD;rxSmmCaUBP-``J}97 z^S28Hcf%7QT!~QNHid9aq=s-m8NxN0lnWHVI(OqSf|~%U2Dx4xUSr5gYyz}81giH4 z*)QTNK+t8qbk5y0laC6x_*@}Sk;fgYO&kI`ryhvU-S3+(w@A=-#Sa;{*{URWlYRtl zsDVR^cS2f39Ilb3+sg%VJSEscIHaOsHr)hcMPClo7Y6o)NBd2LwR}g-)Eh7OSk42i zx=Gnr{kc!mTS3I_>T$4>pnS@>0VyX~ir;hSO!%l z9rUzqC|sJ#*;=sm@bX^T9&A1QZk*G$9wNoMpr#@Hb@HvEA>r1;r+Md_q5nth=HAax zSgm40;3r_6y+&e3JSc;eunAC?>>Bz7^lG1 zDkAiq=XU}~uH%|q?e50!()UHb`|wW(tKyQu?LO>g_hEOi`>_4|%gzKFlU`;#g`Q)`ya3mpLXUBm|;rJ>B;U_mrvE$;o|{+pukP6nQn z^!UZI!GPZoJj@LF-fH_7z;=_@G>)H^(7%EIU=72L^JypB3~{r*Z`$ki2SWcGg@zq{ z5<}~tOnKcN_Tkd-!sNrWkHg% zUg)ghxd(VXvu*NN#{K#TQzBx2N%^!t|0l>3W|YnP5ej906AJR@?=zDD z^;`*ZxoLO_iYDRDM?w6nt?z68hWk6jn^mHVOKsSTE+bVS>T2h7ugqWOA7#p0DCLJdzaxw0WCt?59Mpz-Q3Qrf4+? z8g=$^(iNyO6c*WoH`j%W2G5QT{0_O20gDF5XM)oL z)Vs8?L#B@6HDPGEV)put8CQDzZo55(CyQzbDfyE(kgR0`;b|#jlyYGR_>&31M;hRY zo9D1{peEF0DAz)@Ev^}asnhg(Z8N`gTC{A?N|sjV*H`$!lrHkC_%j-=wo1_V!Jd5W z$M;_v?F)=m+ml@DO!7~q@tERwPS_D543OtleDC)%E?8e!g8M6U6x-rZf?qv9UL~Ov z@gr`a&`0Cks&5tY;VjD>&9}S3)bn96elL(8p}c}BMb;~}W*D-C2<#=R+)%w1tXFt{ z)62H@R|07nKMISPgRd#XnXZsmRz1cz+G2Jg{(rE-5&pY+{F#Ln!+#_Cjqw)uM-lz^ zZhps2wc+^d|1y3>b_2(7OqDl(zO}6LApzi&* zHjuPZLoP}Uy@A&KYl59Q}HVB{GEieb$&06W|rxcOL2S_B*@E@1c9XEE|pS$+gqV_xL%^iJjg_*C#$e1GIyvi=!Ald`WX2KFiv>`P`ZdtksVb3gIV zi`+SSkTWD@Z1;G+U*wLp&xrTYk0g0?;QVv>$AL4DUL$EM++-u(@KmFIHio?NJ!@&R zV%~RyhIG5X>w|^YVuv)`Ri%OS6lu2WXEbP%$`QGAxI6@+b-&IVGIs$oMawEMne{>6 zRL*;|0$LW`)@Q`KFiM@FgmwQq&bUG7>ew?!uw&=*Tf1#P|5EUn&4 zp&6{R#_j)+fIQl|w#I-)+hF{w>@??3jIZWT<{$_;Im_(J?96lQF#mDo0j|)({+na(Qmm8}7 zr-Ge=^!*GVAC3e;!eQcg>$H4Pw)A*NeJ^GYhVr}MEU)$X1Atc*iKD{!i~zn(Ib!<5 z%}HBiGP(su#MPGF`1zC58Cvvi5OZ$vOcJ+@=aXJHTdYvth4f`OK)>fd3|+0affK&t z8qo6t`j#DG&wmZ_wbxWaLg>u*JCqi(HSbSIDuwS1c?*5eT_Auqz7eYGZjVyje$cOr z_hS^=cLnbu{sAxzz(c(Q{zGt;+#0lf0yv6A$DB4r)41VJf0`fC53(%b)emkPUi-Me zgfZ{2vUWX&EmGWHi1YXXqW|3X5gR23RK)*CkWI4>M??%``pX-FFMSU?Jy&+JT3{zd zghwsKb;=(s`(f_NdST?lb-Ivst!nJ&UyHVwq5l=f^{qYSNFXDcC642|`NLW_k_%$0 zoa+nSvr1rH&Bt-cV|2`!K8|ap;C>dkqO*rkeg}3$iQ6p#oex3#57RvKW}wT~YIfi8 z(DQMW*n9vejNk>L!lRW*h_x$KX++8wV25l$sbQo$#b|ePn4+Eo@_J0 zi-bt{^(ew1g=KC|z5B`xlk{5wx1{&iGO2XpNR|tC6tyE+w_;b3m;GEx^XpM(_Gc5= zo8w1khWORNnfutXpFBCiYQYal3BG2UZnD*`-&-aWa9Qu}2G*Co&zF^lM;CuJ-JSt= zx5ee=nUNW?b~kzHMuAt0y97V0#z#SSg-X=m0%`9^r0$jq%qZTN@=SXBd$Srsk=u#@ZLl zj!=Jv_U}k)?4(9&4NnAOt_t6tN~L~by~phnRT`MFKlUAxZzP-m#$Uis>?ugvOZ|Wr z4NyB9J})nn@3b5_=x0Oy^jAVp$!_KTx(Ag6KxCUc9C=`)-=-Q~!FYKbwr@7=YXN2} z?Q6q7p9gje_D8E|W#e-v;8{3?LL%U(+D?CL1h3lidkU4cx#Q0Y<0SI#{pwBDu+6Hs z(}~W99Lyh>LzvxP?|!_CfNK5_5bRez;h{`8_LeqpYeM$=%JAgh2%+VJq6Vb#RxOPW4If(3tQ zks8r3$-D7qiY^Md=x}AH8f%7O7K_~h z#wFeECluDfMJy8sE29E=k!nGs~?_BF`w)_%elzxKwuTuETr{r1c7nz%B- z;0bwA33VJC?L^Rr&2a11jPm(=)z#crUBz!;oAJ82^_-mz<=`ppnkMxHu~(1@;WR*C zcz;IHpI6LY{ttgo_!~g^77n8HK^xr;pT2~1IkUjT`cEo<7+?L3Ka-W>0sg*7%6{|m z`t7#wI!#y8`a<$eybKR}=}xcl-0iymU@K^wus-?b53NMM+nY`cefV@9@ba zw+4b>k)$8v8Oi5;Nq64_9C>?oxtRwOfuJNwah){3aa}bToV!;fw!>g-ZL%xcbJSI^ z=g7Y&_8cK@IVWT2Gl~&;hV{v3`FjrQz;*+)*Iq9p(r}n*IB0S56RbA5iSpbv4WEok z4z*pl+354+)Z!#Z`w00vwZ7Z1^klEc(S?3#veW&-FZ_16&GBR>6`<#5(d&Q8{-U)X zVSmw3vm&APSLIC)oF{|aUvvxCKL$kxEER5af6<%%f>-zD>&!CD);0sG8HVVAz+LVG z-zWK4UR%QbMcXLltC?Wi(gVgE6432#J^PFJqzy(|!v#(&;9*KL=@DLL3yV+kZV%t` z9zLS7_)BjvI(TV<-;?s@{4D{T9&f>XydUP*nD+L^IrwYWv;Oz?_7{Dw3zsHCtcKm5rOg)Xppou=DZ5Su@#d8teW7$(!BU9b~5drLp#Y`~L$(FPkwQ&OVke zWpvnrE(XL~_A=js2+e4?NssRGWi~@8>$QL{%>te!g;I@>qtSK2ZMo`-o9pfexJ_@o zDV@n(CX3otU+LF%=i4f{4;KWtR(Ih(#wEZo3(V#-21r;2fGkEZcbR_NOXq1>ARQtI zpf>k$4@fYV?;XUK46`ry`PV~vS%~On5u?Q2u|yPRmim|N-XI*HLxQ943&GR^&Rp6{ zM83Goo-fg}Dj9!>L>pp-TE^%Zk%8scEaRE0CpCpo3P#o+qc^t=lTfMvh6nN!Ff|C5 z^3X7+qoi)Cm0RStgQUF|G0_Mr?yC$Q1l3tkp0GF}1aP$4d?X*6-RfT&9hrcKtju-{SfG`bCYmHQN|v7->^GVXY3=G!Am*)ECkwo$hvG=ZJ_Q<_QyO znfv_p`Ye+REAth1Nl16D=%nBM%9fwC00H0kQi$T*2z}Gi=9qk1nuq=*t%rx|H5G1+ zmj{2Ul|AP~PlxMdJ{X3Q4agu(IXIj96!rLk9To%WS;Rg_*&B?E5pKp_U>xkP{+vAr zHj2UX^b^XR5D#Lo1}C1GvK_>-sd|??f@goxMvtqu=Sr^(-D!7NK>Vyj{SKQwph@5Y ztAhCOQEtphy1BZSS)N9#E>J^lQ# zz@G7V6xugcBvW6sqS0dwN$k)3-ZG8NcK7FLzUOzN1pyy^!Z)UB5cX~^D1A;J(29=- z5P??GH5#;X)Nd7pOM3fK_TNl0<;kRBk$0=^7HW|{4L{vOl^XaZuq)aROVRJQ+*UU) zOKXPvEypQ=*=FoXyAHnI_|vPrGql3iH2gE@tVH}F z+MvXpPtHXA;bV%SZYX-5z+!#UX!^h{X?j5>#$YTj?ET%b_utIJ{X|@40t0#2;&t+j zCe9NWx_i>zpK}!Ba^vZ5P!0o`3~*pj}ZUgBu|(8T%-H# z$kPYK>yoE$-ISIOn<`HiUE}3xKfmvaJZ-0<4a?Ip*9sNM)8z*tPk*rrnb0)+RTM{| zJl%(!33+<4-&$Dge3rBHN%Hi8KcwkZI9}}i-I1rixiu|MZ|6NNPjB4?dAcpC1Js@S z$fq`0o_=%4Amr(MkH-Lcdi#ayhi>=59~YIUPt=oq96Zw!`cLjt%9)u!J$y6)c0KYG z=SjuQYZ_LRx~n8)HsnGn@r_4_6&0zge^*js_Vvc)=?}S-!P}>fb2z9r_HX2P4gDyE z(KqpY3}HI8r>1@dcbd&vhi~Jp1-0Gcy4m+^h-nqw8IADw~T&>7yiyn?xTa=p#IyX8l~&i_BOzc2l%q}SWg7guR4 zOJ6*2V_N=gs=kvAgEu)Zk6-t+q6 ziv7_S=k}YvxE95j&=;G-R&Fh@68hrATPRrE{vNMS(id0WkfztWp)cg2qn<`H0h{a` z3(4V)@7Kxgp!S6^3cE^i6zz& zYq9-0{q#B&C7t}{0W&W=+{AvJ+kMk}$duTxW7x~TPZPCYN5t1@C_%ftZyQFq?E3Zj z=PEr<5DzhSkpB85aAPPwEqHDol?L*&K>iP$4)74)c(`Khvken!I+@mCgLyrwCn&>J<6AW0ZOUFqqZNw#zBjF z>etpu+)CsxYQ>%Goxv@xU7zrfxsg0X`<-L{8v1)omjeBlST8d7>~R{1mZ!MCF_GUb zXCXuQzpD0Fnf1-@Lj7FDebQlGgCEj6Gco)3kmRCM55q}uBPfUwikF;N%GMlQe?3IA za`Mfvi8)UG>|>s|%Lt=OkK2}m93m>q#q*nqT(QwqhbPGV>rYgQs>)LP48aiV{ua>l z`@b@TIK*TCJ1qGtiWY?S{C^B26!KAXF8p)rI7c5Zfn=#VcW#SyVxnM)3Ex*>K7UNfh^^Qg`qNK(Z)l&0Q<8@6gA-4WDnNJo z3jBwwCBn5trp>%M@#aC3>0wNyw9890LB7_Ng1%V+bk<8s+^`6GK7wu^j_}ZN-ziFu z6}fXf^h8YL%fr{2C-((nAp62avvxbXNSZm*G=HY?q6`Yg>DfaxD1&vD`Tm6wOhOnO z*|omlNO;VGBfAC!N2-&|DW0@HC0{e9Xt{sJ;v)Zvv>@V)3D+(awtPo0vikP+^`p`u>097K1=((ojW!BFuR;d!GnBsTl~VWYK*W9pRf$o?jFR< zD~yz`K3{=^$}2E8xBBoiY)i2$w;R=M`^|0KiR2BgpH?5)!GRU?nknJ-;*-u1teB_S zi!iL1H(MpBvfAB2CJnpOEp=&-dV`>HXQW(7Q?@mB%k$pj&f&#%{@k>f9#46Azdzd+U7e~ zA}@)hL`OXbjrRfEk(Eb0}^#(A9-R+1xW98tmJHNl) z)*CG1V&M73S8RoUtQ^4%>dp;2uyAU#2+ZkZ^_opzY-%&(nRsgRxtG=K;!_)~H(0&H ztpXni^gcZY>kU6WL;cY0%Dy8iQ%y6Vn)&TPE_S&)zDn|Ecx?&&W7jL?v=A(-(%|jE z-o-PAz1o6dZX)_PLFo? z8o#nMv2?J}-Bf*!!@Oe?I5?lE(vJb=cR3C>8Az|_yQzss{u$=+_OZn)Rso_5-tLiU zyppcuEO-J6LerSY)s$(xManc@>0UkDo5mo#?r$LA-FOlF;`?O|#h~&>-~rq0&q>DZ z;#8T3N|pV2(Q9Jk#D1BZl#tplv&Xo^ei^P+Gx6gg1p8%P?pGOshABO0Z+VXN(3`Oh zTNoD2?l=!UVH?)1(&b+p+b?s{>oyJ`n(RaWB9rhP-Y=6LAD%N(^UdV^=|5nfr0tJi z|3b{PWQ4@bm8*@h%G2?{MdWkO|2li%(nfLD+wy;&CJ6F>{y44Qynp>n$OwzpwZNv0 zNZ;1vF`clj?NR?~78n-)riVDLxW&nI&*aK8*(0m{-oObpWF+#)(kCVvHFE7$}c>xXy29%xjf2Hs~dr)8_CPZJ;8VS7^ZM-p#eur19*<6WPX284pH2_spZ$`$pxgcPf}-}o z4PP#_2Y#Xy*#idlt)E%*46Ln}6}Ja2H{xu-9{9U&Hc}w62Sm`&9=IO>3437U>t!>9 z7n~&%>vPuJ$lrK^UI+Lat0aG<=++3h{55M{Wdi8BFEd{4*L3sAb()wG5*6&0t_PBz z{}u4pVAsD4N!Gtcd+ooNUt|1b?!O$r(6F)w;XMsO+^^;5D|1&a5~%|lxvA`5J$gfpXK#{;8iiYPTr*ytNjYyz=MwfSysDcb z{kAB%Hx{}%Uw~h6*T@FCif6gxuvP>22l1`??opLE;=|-t@^{FextMR}e`~hAdHZpZ z2nR~$nk-N{S6feBe0q)?u=;dz?O)iAZq+Jx0gdkjE_8!ldu#JLzKCij}A z=9$X4pBPk?c2{X^&0Q)gr2Kr(SY$E|)Mtd5yXUO{)OZ!Gq&dN-ygNw{Ah^5l2Xd@L z_jwfXTT1_%e{_JqwFaV$;1BTWeueh^ob9}ZYC35LeM|5wF@W?h=K(9dwsKN#D%yO= zo|Cf2?pf}(RV^aMq=bgvhdkwjL*GF;JM}gJyWkW9*6*&nG$HT3f3seA#;sliQo8#>$?&0e z)}>VDBBn?n+^vp2@Y{d|{3Z4)mmbnm0ectVM_N$QIH8)JbFSal(3NQ#_ORwy*~};^ zG>vJih8x|H1A9iRhHM8Cr6-RN2vOVO3#9a-y*g~4UC6Epbm$NCWBhlUp(q{t`gZ8h zpSD^cUpxGg(4o?}?sw!&=+O6GNgL-bt>;rhjb3a(SKHbxym{>R;k(2EOy2(^`^}cb zj|k*n!^)Gvnw~3r;XMi{fD}aC7Hsx}(>ma^&UP+3;y>uA=2yDYKB%+MdV;i8OFP%n zo(a<0EbVGbb3t0((mwydTa*pY^Y5^F0l!eZLtEQ8j zat>Ug6d3~s_N)ZhI-b|#9C-b28*vVN!{9JUij4uSXoki>{*ok54w&yAImq?QQ_9xw zAMoe-?N*WGc{Y3x`89kGd9~AB#CcpXpN8)dkJ@=%>2o!&A%rS%u4ctT zx@o{}h>$-E^udPLU+wO!IDW{sx(%?0&dlV>b~6-$u`Gc;CrJaij3jYn-6Hp)52xr6 zd~4=gv)jqOMYIXNY3#SSZS7k`r{J4pK&#vDsT9qEZ;}OV?nCx1qF?YW&$qnW+P)>n z`m|vwS}x&SC1`o36j*WlE!w}WVb3rzGYIK|f{-@uVDQQ)K|_31Qifqv_O!xl+ubmJ z0}qbuVI@6E8}<7XzuKNnsq=zQ6;I0!YIi&G8#{Nn7{S#khdE7x-PpM;xrES~Dunt{nZ>%-C%!F1w49E&@Y$j&EnQFWme? zA^(cP#F820IoNu8kpBK_|E z1*!Q@(Et6Qt3F0A4emS#M*%WVcNCy-x2rf(JylJ{;7S#3C ze*Oh$-gV^+^R94zAE8!B2&S*Re_;w3wg93P5N&{f;ik8MVXNIxx_P+MPiF|Upa14M z7PW2ZzLPmn7o^hkq00?>#70n;mb^PhuXDrBrY&Z7*=?xq{V$o%BhR51h(1r~t=^+u z#O_=3Oqywleh+t?z4YxwStRbt=s_KG?L}nN{ziYYCz9X&-M}J^U!9+n#^HSin@0aX zPhcRt`}D7Y{?I;ounUKN5s+6%|GfLKFievDhYySFQ@cj%I+t&#Gt8#9BP`voUND-& zOEJv}3`KRg@`eP>pZ>O9B2q^WqWNg(YBaC0$(?Ba#TNw@nqNp?4bWfkyN;)s(?M`J zF%swqpnQFbgjTnE1Wz=IOYURMdl!91*z?k`R2=U6{2}`^$39WXPE->42VhlQdjw;T zJAf-|-Q}x5#jB3%^%$NQazx}$>xZywsKdqrXYnn_l-ED`R%6CLyjlO}&3I;LnEnQB z<&Dp;^Y%>uW8?ZUkUwGmHU2(;*j`e!l!iOX+M#I+`;WbcJ&YLtZH*;{B)Fl zAlkPjr-F#gAMy+VbMr^qM}I&-ZoZYs`fdG9Wmjz>bHEPK;`SoN7Rl=2QSP#G|0rLT zJvNoyr4+?SHI;E)jUE>+sO{NPcYPzJe8sILZaLqU%|D8AjCddSI$I`VlO0VUM6E%K(~_L;bZ&{xyVEAz0LK>SQs@?KR|d zrEqO5(W3Q0?{b9e|DpnxEbH@gB|OMa303$xRcKSeaC{|IMAH5OGD17AaT4jc z0rTa31h-)R5R504PnHeq3&snW)6OFHKs{|O`ls6$+w0yQ#-qPh7aLNwKd-gh)z(|J zvcO~74YvJB`e3GvaNoHKUW?_)0C`m)ze4*1^2km%`vYOCSjf4DEjRJ_SlLENJf6Qb0-sMAVj4Pw;yI zz0d&MDa^obcNSk3fIVE}#|w44ufoq?lKcoQy}aIZ`CJ9fBphfvzu~$=h3|XWNCorb zIR7Bde^vWNQi14AB{IOK_oyOw$LC}Yb!(2ZM?flf&m*S1!gx9buE#8rnokA@BhAzm zXA72CKRiS<< zH|i7hSXPPiPRg-q%x7;z!B70V;Pkx*k}b8S!RlkeMI zN6o{^stk6Jc+?)R zZ%0{=bh}@Vu~mh#UJNa6S+seaom@%hXddu+h!R}2r>Pn?MTh$#-*UAp|AfI)a!^Oz zu5e9{JBf_o)5S}dn_^w-j#J@Jo8d*iPg}kNeZEd!_}fxe!@5o;EBh$#?tQSX%?aJk zdM}Zw=--F>_teQZJ?=@IqmoSfLzh6`hyKWEFmxxKra&~JTUNVuD@9z*$wBwqC#fL5 zBy&%;xU2P!VaF3$-)kjPt)$|X8A}3UrdqJ790F`~|Ub45{5}HJ88j zRWSi5Xf3`jPY3s?{&`#|Hi>};@>;>1|3zVJ{s>MzbvOUfG`nW}C-hKWcI4G7creaP zY(wev@$lRq9%egV+2mr%z@Cx*hS>u5h~|OOb-Fc`;3b(uJpRF=O}jf^zlJaJ2i>i4 zq4S*@ZZ;V?Dycog{*KPmw!2cxAR$y zy^Uw=QHI(@exMm+3&tYABbn6yUm-uNdnP%0kEgOf$-ITr54VDoeL)D%n0bm)w!dNC z^3B!6F=yFm9sZPlIFhw}F?QBEca%WgPL4lm;T%vC4b)~HRGyc-aJVMGp=|Ao0yaYF zelS(8gXg;?S4#FbgVpNh z3gT&ksJUf?1q*f!eem=nZV zg2+-}3~{E1xCn@ZnXGb;h7hw6M82gV&hQWq62#pF5!Q(z?%*LV1mZ$LEI+{WTiK2g zM82gVZto$kI0uNGSk`}nmNCSoB-83fAT|o($3uwsuMAtww=~4N@Fu|8mkHtpf*1(< zaRBLYXM2eCywnTgmqLi=8$>DN8NWgYeak~RN>Hk0@vHC{70#7SiL!n`SwG{m?y0P- zzzJa~9QR%lxK9LcN0e0JlU}8bVXha>wp=}lq(^wkvh~^X1i165|MOipo@KWXF7)1$% zBmW`!j2Bok{cH9z?oR87?~H=NqgP26Q+u#DwF___g*I-&E3&F8hVrQctEzWjb%$Uq z=rpqpR4N}7Xx;QOcM9xhU(blXzQR-R^<;gGj9L^x)3E8(K|suiOm5uw`lxQ{0f>7! zX|r=nRFmcj?RHgg$reNWYtyj9_En+A$}mIIu&?@*5tf3rRQGie9iQ`@N*YqDhJ5qo zpdr#M((MOzSp%BJd__1&=beg+NCF;J<%7Kugm^of#vCF5|2o_oreyrCw4U}gi4dbj zOjD54m>>jn^6*0CxUJC}Wv~x;MfRBNMfKO(U#L0s*VA7!M6AEA(DX6vuRH8zTm=-$ zq1Svh*`dSK(qFMSV4N9t=uDdc&|QnJ z1(rJWhxe?fLr*7%8#zAe(A%F#bm+-8bJq-^utR^SZ0hrI)**E0=fEqRf64#bDEzhH z(lqW#CM6jk>g%>58wIUr7n^x*Ba!pm?L{F@>2B>oiu9D!X&C-WlbhS{$_K-cu)meP z{k~f}-RAd)-J0czq0T|m5P z%<>yVIkVCfXX*a-SO3A=ZFN}x39{Jj=%PUIK~1lqK?!yOFJzFky5vwy`+`~w6fSK z^H!Hf{8fZZw&hA|f&_j5_5I*t5112PM&#;ijC1C!!LHR}XVbWgt}ZFLLrmmuxDz4- zjhjaazaFIVhw6jJn7wHUHmd+PaF?{t>2iQ3%-&$tlEg;$3$BPDM@J^O!FGo;m5I|y znr@mVqx|E%<7_DFy+UAB;#lSIbC-U1;2#55{@201-%YzYcpXI_QZq?YPg4cFi&>^r zY6kKYpn$mz4SME!+Va%%#!N17$ktU@!9%zK*j5R)^JSSaLUg0S1+Aw>hr)!V9^HilFuzoyKbkSPeoUW2t)nYSE$dncsELE1$4iFU~D7R_c z@T(yBO(OWXJ2Y6Vln~9kA?7?*=k>T|m6*F!q?eO3(r*F(&<_#+s6SX)ggF%-0p8qX zUN4!Sccp?@hanJ6{ul?| z0a^i*`1q~pFoOxAo6c+8o<*3YmLdAntSh_^4ahjjAdTq_WPKjF`MwmV6dx%>5;KtcRsp)CZs zJ;^tU2VpI_+Gg5X|Kv-JXvU`6da`v=lKUSKEWAJsUOwVq^1xpMs(Ckw1mh>dFd1)O z_21!ukPCWD;mkVNQX($sp;;9_gA2Y767Im;j0<)Mj__{FPW_1*;12r)D}#H8KdhN+ z+(!Z5*I?iF;2X@LKDH>OHuqurCG5W{#wxN!bA8|KZjbV?893dfYR~pYBlzh8`6BX3 zW&7Q&Tc*l6cW`KITDgRLgt7^L-X4?-8Oxk2u{=rnU&bDyHOh8(O7MH{7SvZDUklb} zg7WG5o@UDD%MFm9f&Ujjs0lEs0rQEn)7#hsDj`2M^IfNrB+1t4KBENfWeEJj$?;cd z@*4@8$sOp-Iu3Qdp&p}Vp-@WPO2uHD(x#_xEvO+%G6(4_cBqkFC&O?`feCvYz_m^#t-5`vvD` zYdCtHm&B)N|Grmf6c9Jmj}fh;4JM;kt%3EF@bW3WK0qG)@RzE0i^CH=GB$YR@3g2> z6B}I=?1D9%JNGb{Ru8s*gJcA=$U?P;q(hNd89G~>BxK8|_ zzq$>cCm!b&jWvfWXkVg#3Ha34l)Vx9GpCt5uWk`GM=LPf@W!@*8_%`)FxR;}_wDkG z5Jx<`*I&qtG$%gx3G?$p3;BK5xprmDiG{mNtnoOuwr3X8sPL69ea}ET`9oQPt#tFo z2{!j@>-V4~vv#JEE_Z_glAE;M{Z5gGI(-|52sVap;$*Hb=W?~XD3NbLnD4zII@S8> zMXO=p3v<({FFY|(c(MxH9F$GRsth2CE5ngXyI#`Wx>+4AWJURzjLhJ`Apm*!%Jn0o zjD`}K%Z*q!AE<&$^mX|sd1TWvzJXhiF4&|QB}~OTrahJJNM0vp#rEN8PRSAL`L&Rr zgH8?SLw>!X687n#8xdGYG{n3c^&w%=?of;LO}D%gOpnwU@{qFm|6}h<0HZ3BzpLNe z$%G6fTmj*QGe8K#jR7?rK~Rnnf&z+3NCt?6WXvQS3TqH_!GJ^sML>*-g4Y@m6;xzU z1iZ%+6kJ9`9fWn`3G2o8tA1~egmAd%e*f?PZD6|I>(^afU0q#WU9Y>JcEul}9L#hF zgSXHQ7eEUG_;_4V=K9h5Ke4_$wZ5-G-GPtw9ZTu)Vf{r&K}Qb(b?AeIg7;ior2Ima zoTUA9erfWR0Tx4-p>yirLcdJ=2(s*~ZtY9S=p9(Uq+O%eVP+k_a4$0rog1Ah5d7q$ zi00t5OC=6M7lcN{f{OTs>t%9XLNkNiUzPEtUAa+%w<7tI0v&a4X-gR~Pv+-^E4za8 z88`ZH{POMEhZ-lzBojFaa+D3=0t<1cooEmYI(jkdeGbS8c0$Pm!e-#HG~X~gki)(& zxC-h5ugxOeCNp?=3K~=zVZitZFW(5MkkIO+TJounACh~%VEQ_qQ~6xT699p1d~6Pu zxj+i5TKS<6X*0v<0IwJ9w90{HITA?1E&}^~GU`dr(|^2Gdp#)ovQ)tMs8kts(;s<+Ul3y_P{u6afP%|?l<85Omj>p>(!+F+Ld%Qi{@h^u< z35|bG@r{0lWK&+H8(txLA~;n(V~#`0HADYQ38cQBj3#{7@6;`o=$5 zf1Q|HLg~We-`;T`_0;3vVScP<9?6+Q!h6#Aw~SMsar|q}Rlq{MsPXT|QJhhZe?O1I z)9CRp{c?^7kAKr~`v;7F^N$9kJVq_St}tEv0jr+!a(<$1Z>)xpY~~kuy1tQLD(9SZ zSod;c6yftn%FxF&*Vl7bV@z18?{(lgAU5jh-(Y<^hrJH+z8N$^@SMBH`-C}G~i zh|*cBfi1zikrHTXfr{mk zXe&2rz3>i?k80SS&~1s}n;-&p!6=Ey_$8Sfw#2lwF%7Ce}*-Ng086Yvi2 zm?})KphZzW+JehxT?xMuKSe4GkUZ0lXy1@M$NG1g9Br|B9f^HG^IG85ydE=I^TF`m?)7^S@wK zr0$F|NcUDku$aQ^NLlKuQA&02GY!WEL~dZj zSiR3#?Q3vG@On8Yh8L-hXA03dtH#NWSYdkG&)my!0x2sSJ}wRI9BtpJC&^dOhhzmH zRB}Qb2#$GLR#TUfI{l6F*8qJ@u>bm6`S5)YEg$SDmaZs&0|rU95oJd^9_;BjwLgY& z@5(%mMng3sHs$tD4f4B95s3}=7l)*$7XDadKFOjy_59nw{;1QYXWGN|ymTRj?0J{Q zjY+8C0f@#uGKyA5{KI!2p(m#XnVjQ&$>Mj+$x{QO{(99pUB$>I`TGO8VoSgw*YDmzg@_Ft3W!LdTRzVJS=j|b)<&^Gj^%&FpTui43^^X)C0kLF%{7#H=q-v5ENDy(5g>v zxIK^Ho0iDJ6MocB4(btUjrh+%+e!4+)Y2bk;eUh9tJB^*X7&rN3{QvaK1culnU}KH z>5r1PnABDbw95T2QViHrIH z{nhwq_E)3UUw2}O$^Y~H75(dfaep=bj{XXT+7HZtHHZm?Ja?Zb7TE9ohO~9Sr~|?8 zUYFPGf9IEkdxIMhA#J=E*e*e+Iy%xG4+D5u6Ks!LHXb?WaK7eA9+F{XLOf3f+c74GO=tvcGb$`r_kdOe?@POXMe^1 z13WpG1V!Et{6YSF^-amL-LRvu9++=*FTlk+r56CSYySL>@)MlMw=jxb z!2wKv*q_lLs*r=PAjK*C`Co9u>cl)3N*DHLtmLPs_GdgCm3ba#KBYfnw3MGS`SU02 z=O(D-&oIBhXf=QS^SF%mXLOePO2ht)D{*^{{tT9f6)% zdo}xkeMI=x>+jX=L8v9^U%wj&k@(d9b*MUB*F@%8XXU?-o^PF#e){nnka$-5>1d6t z3@gk(Tt8JE1@4f)^*g@NrEUH8h!pWVwe|9uCjMuspR$;42u&fwuztEVs*pik$SL&G zl&Ew`p>$#W)Qq2=T0eD)%KV8>)CUe>qts6=e#K?9 zewrvF!uqKKx96yz!txz0f1lm?3s&TXUMui0S=ZmeG7kUBIN0%~xNWSD$~B)Wq@QPB zcv~l(CAEBFy8l8&A3>)_D(PS3c?3LvTc8ii@uOjF7j0m$;9v3}A~^prQP2}fx0z`T zj!KVs3Iiw*g|eqmGaGCBGehGo-Z^8Xp{!Fq^g1Y+>Zjq0@b|AK9VhempcI|Pv9;?nd(i3l+u`4-Po(@~Xr6HU-lCOX!63rV;{#7u z{zEVxe>XoP z@m3UE(Kxnt`Lj=3KE82rF8qI1+WvZfx=|~?f72^%7+roFz5cb!pMBc$ zJN&Nl_4$nUz8c+ivosA}0uEgGwe_zs7BI2$2kqc&_kCd#$|sW^L()Y!0~LwixBwp% zdYO;mxKti%sc$!a0?}*_-m@#b5%PXS@%!psnTLRrj&xvCAhiAQCQi==%3NF=Y0EFM z^>i|J3S#TL)P}0r9c+jA=;@m7FRHb^0%HnZvIo!O5>D%Xj`E3XBUTWbOhS3;_~#uF zn@&&rN3P%C@ky@b#1N<19Xz=%2Q?vo7{jB-*5!6yGDP? zZ?}Ta^I9jFnBCUFqx^K&0)EBAf4IyEUFvS=C~v?Jo&VAGYjGZO)$wOWKVRMS^v|zs zbo%G}?5BTzrL;|WgLn#uqD~$!uF(QRj>saI{yZCQ@FlNPl}{RGeBYa;WY;`1?74cG&WYo z_2hc;3$^R+;CHPDf@8Fbr_@>?qxrMz^q)|DHG)E065f^X(IHwVpDz;K{{IGlx$SD% zqdGldT@X=ub^P!3zdzIMc}*Vbp@-|&4~6cPZyvxJyw;aphTq*x4_`M6oh^hd@M!2@ z&?7ncvWoLSO)s3!-@oK$$R^KF_up&xTcs!yKIBoB4k`_%IMR;2v*LghbF`Dc{R z{hRxdY)7atmWNZ5w(?@aP}Qh$gpuReTd?k}1=uwDtRM-82E zq~nX$FMpi;)YV4|UdB8YGW5l*S{sgv$k1uV`~SE;3iTiGD|Bl1(z5T-%Z~>!IJu4H>yx)L;QJ%=>s8p$_rG7irpe`s+IY>E z+}^KMoO64hwSFy%lhBlhuMaEcL6hG5Su z;7jgr6BnIxe>;Od{N3aE8SwoP`t=tK&HwxL>s$VCd%wq*+}_vRe9rBC*7~)#;2>ZU)V{Qv6L|D=BHu<*b7wLbmY3P&XC`n4@zvb_Iv<2lRw8T8@*ME$y^)4!=- zyPUy4(B*gf2jmG9f0los==E@Wd-;;vJ7)eF+xx8b=UWl{?}hL`QvUDY|F3@hPwGeW z4gb}T_36jo_!L*o{xrO*_m_|7ol&08r2o$JyiR{RqyOm)`2Gm{b8fqTQ$PMcI_W`#?%D*F2{xyF}`Ty0g|4IG&(47D3*ZTD9TDd$^ z_O}Q4lKb0rv(LG|ok1V|PqaT(J8w>eu@8>xC~u$Tj%1?GdSAxR zvB4yIe<<`x^!lZ``yb^JU>qgI`x$r@hjv~dZ+zt)seBY5zj2g%8zp^g@3B5W1t!72 zeIUqdrnpRfE5&BM)z(p=SS-#B9WhkjdY*sd{a!Tvp*0eJ+V_{Hb7fAw-U!R6tiitF zG@aLNArUy7rv0kN4dG+CE$*9r3homhzWYNGF&%8NleL@|4|IYg+mapjgX_9%W_xU(W z0@5ePL47@hMw7liu?{_<`hj=6Y8^7nbvw=aqTi9s#Hp zsc;_Q<@v$jK6%$KxIi}9PNeV!r}C6go)LE}_$Zdw3}0{|l?~t4j4SXI7J6bU2CJEB zJURkJ)BB&5h^uHkZJBKK;7%kt(hKF`1m#1V@Gg#Mq(|VOiO{Yh?As0=k>%sajqzAO z6dxP4A42vy{R9-b`++w(s&bt+jweC?<@K^JTnAG5VsHspaaZtl2{UVsG}HR{1-DmV z1@F7~GT}cROdfZCsRO0Pmg`9)>oJ4ZB8^ z12+fzNrv!#DPBOvO)<_F?1V^c62QqLa{taqU;K+k>w@FXxfj-sIR6G5{AHR75~Wfa zhuk=V4+r3&+koV`@p!N+(~pYN;kHox!Tsa8zP*p(InIXt@ihjMc7w^?-wl>u#Vj}w zpeuFT!sC}@g%@o?DE zt^B3U;MGV24lUifnGa1{s(r9?>A2m&GVKA6#Q3YZ2vtF6?0t=vw;$(a{4y_gaB*Ia z#1bQaaIyY?Nr8S`x63NsXpXAgd7lE}QQOn2K*x<|BhE0L~BPuEgQ zx02I6ipPwv_YjU;yz4oswMKAO4)$i)q3uBTJ8;;`x8CgR>|CpoKJAP3=phQxR3<22t4M5?3E0l_X9nOz^3lS_(lgGgr|)*dx1GHf(M|`8bU0|W;!!;`&m1WZvN4g zve>OsPL`S`V3jQ}Y#z4wY5w3WK4`0n#K>}-Z?R}Zg_f>jD?bc2mi=>A@H{}d-BoVd zs0@C>-%nV|AI|wLC~!!^aHyBXIM9fXaOAP>JU%!i$4w~;~7f| z&MxJ1m~NN1BPy0kGAeK)b_IlS@rZWTVT+CJkj#hPSUGIz$dx0OW>)bRSy+H10`%`P zNryjpR2In8jq~wV&R;@>;9&B7NHc#2a{;#dz-%c!JVYLGfMz*XvcBpZLUkW!je6t@ zZu^*P0|82fl^(U;u#PbRE%rJJQ=Y#tDQ9nnbaFQbY6)zUPcP=p#X4v910qV19JKBT^1l5 z^N7J}-!WOI-N7DAD4!RP5fG(8qBv2R1GPYDbGaFMwL=c>2)y41oDY9kqh|5A7Z};! zweO?U1Y zXasszsoYec9lv>1!M{KS-$IK9_k(y~8wLw0kM~RCGI@+xJj}_rQ+8!sZIBP9R1BLi zWx=Q0rYs&dK|bO8`Jdi!LW|(h5ufwG34Y)KXkbo{Y$h>++d(ml_Y&>QJcQrp_z?q{g%+0FM(;+MAmxCZ%af-M-o&N;3IILMpTqx}yo?QCh_ z@gm@YUf#;XdoTk6Bfi?ig&kUcnO{nPo~v#)K)`gQh790%FR;f=aIl(ZQAz z=s@q<6?}uQm!dm??;d=Th2h?#QZX;itOBYk6c+&Qy}{ewL-b|1-LQDvav5_2$KXQ* zTJ^4tLR*GwY?x!sHLPOzF!b%sC~RSL*2B(0B|C5F#GuKV;p8NfX<}NwUUrg9xiK*`C_A ziID!R+y3%=wJgS};t|*;hhfkL1;wMmZeZs@5v-fR$idc|boh^nd_06adF@6$YLyOO zy7w16l4m#FrAIxX!($UqoWQ0Q)*KjEM=U-Ve2||=r_)v1&~?iFERVAE)ERH;@F%+e zN`H;~p1jNx)*oPewEYq8KS-|zJBG`sH@#+WXg1Mqa0~4)&d-Y*_u~Zk-O{bbs`4_f z6TW=7bl(0TPBz5yN3Jp2>F+`5ztB%ltQc<92Eh_X_jiZ&ZxFxYr3D9te&kqJ7z?Ov ziawz0_EO#Y*0~SK2e)L9>H2<~6Xgeo8oBXamIsHFnz^T9NBxgSn6S+6xpkNQhQk?= zWUnkTWPR@EM@G)eqSg>PJ|dp=@~5tRopc{(u8I`D;);)_Krd@Wo<6tjk4& zx{$r8l^05XJh+~_izW{z+PAr$=tTQ=GVCBjrwn_@u$K(`$S^~OgJd{FhC^jIOoo@p zFiVD)%W%95C(7_D8D1^JX)?S|WoGZh>$j~ptcV+m# z3_q0NUKt*g;UO7*A;X{yzmnlm8U854<1+k7hQG-0HyIKRCp^(!k)d6NO=Q?ihDkDP zDZ^GWRAtykhV5k7L53+Z>@34n8K%k5DZ?Hz>?OksWtbtuK{6a7!=W-9Cc{f)I6{V_ zWayIN7#U{C@NyZBm*GSiUM0h;Wtbzw$ucaIVUY|yGAxl{sSIbzaJCGuli^$${zZo6 zGQ3fS>ty(%4E-{ESBCG)@Ix5}WOz`9hh+GL4EYeq6Yal};ZYg>D8u72{7Htt$nZBA z(mdHNGBnE2EJLddV`ONTVFMXDWY|cCi85>@Lsf=tWY|uI9b}jy!yYp1CBr^4>?gx9 zf8o-zWO%s@$IEb{46l;m)iTVH;ba-+%W#Ser^)ad85YX0NQSdzc#8~|$naJfR?6^p z87`OMoibc0!&Nd|Bg3^atdimVGF&IahY*JU%5fF_;|F}tf8{cS0|hYfcB8!Q&u`uH z(Sf=9F3{t*>2RP1gPab3)(iJeI<%b zRohRBlt2w>6W8bG78Vxg<(3wg4Cg1F z+=7zfmlot_%0JSx_L=F<;}iw8GXO(oW++W}l%XZdo}BA-pEhj|XRWl^dBrnk6c-I2 zF}XV| zX-T%H7>(mD8SaW;?UU~=%`GVG(OWBfin}y#T6S(xes)oD$&B2>g6rIwuAwu>_R6l) zE@OLUOGe}2@57c!zdwiG;@x|o5exFNy`?1uMN^08q2arC&qMXHOG|PKO1;DL>PinH zBErz4dp1i!7(qQP9O(*C9GV7p6uP5Xt~0H>vv~3~5W?(SPXP;RA3Y@(8E&>v+8&-c zdg{{LsnH2~I7{49+$HX!Ja=|<3-=mTobL_`a^K0h`Poy-it@O9k*=_?woGcByI%UW z7Vh3>W^Q4bTej`A;=+7)Ni-4NouzX;?vQW|JU=^6O1#8ZO9j*|NADL}G`a=aCQ2>w zQ;CB+Nd#m2$YofU$Yetb@=EI}km$H5)DaH%DuM=#u1p_|(a}*oL6^obSq{1ZomhRD z=ttEs*sF#0Lt)x1Mi4Dj>~|UHKE<@eKo2QBi9S+de^KZM8L_~izHP8PVBjw}l9;E= zW2c4uTQU=xd=^Hx6Jj{QX*t~VK45xr}; zL*V*LW8z(A`qda$Wv1s$mm=mS^Yb7Jf57LUJ-FT@tj7c$5N;Vaf-;FRQxC?_e35!2 zhMo|M4ByAlv&M^welw=t7fVl>QXh$>pegmKSXyUJeIb?t=G0eWX^kcItyp@^@`AD_ zmTr#O2xriV)p5e;Fr6o~BDqXE^&#pLJBkJlkmWTYKJorZ;rNH3mqp5tf{uW78hy6O z=Pea<1HagoY3+1AKF@8vx4Y7G>Bs{AUKV~)KtYtI_vkQ5jL6i|Y zo-WnO8<*SVpMoA0RpM7c`<0KyS_2(3t`dmcVjcn_PMG6wv!ODraQ%WM{$U$^WJ$;M z3Tym!8*Q|@aQ&T)kyORRZv%s3c-pO()t;z*o1>M+gZ~o6|NW1 z)lar%v-Jvj0g0fmlYb+2&BFe;pxXr-29o!qm8+w8-r^ulD>4H~CKm2Ic!c44__VM>X5-mpj9^)xVkp`fc8T~9?260KZ2H6dzZ%c9n! zxK8cGd7a{l#bpg4^Wtik?~ftDMy5&wfRX{(8DGbQab(c>oj+a|i- z%;~GmNyp9fhB;}zg@R`LEf(5i;rP!jO`o#SE!M2vHVRmi-m%dyR>#LSddOx&%oDcT zm_kY4paz9e^tGgi@Z=#hAbPOq`;0;h6#F|0EmP38;QyJPHz$Z;Sv=4$6fQyq9p4B# zB*J~?O!?3Cc>-NRbV+M`)YF>?#rIcnsn&jH#tVt1$Ax{9LeGo7I2!*J#lBaeJN0@u zy}@>upnnO+J*+Bk6syr23=l<)C#TPQ9(@Yjp9=d51MoF{!a&a`S3Yi_+YE~|^(y&# zdK{MyXmr9zu7q1nbZw)DO>~oRY&Ox0qA{*N5H`Pwz7YwyzFBbuP0;QMrC{Rp)q{qFB|NinCNpuGhClA*nc+BQ^t5)?=Z&SZKe;5%{Q3oU2_w}d}U5} z+d}`a@byhr`%6~(+{)L#S`+r$Xmbo-`(qMT+3DF>zJ5D4VY8hM#Wvk#r*G^Wvp6nc zUjzC%j<4@%knm#z+R&isP4Tp?!8Wd1EqQrT%Gz^M);?fa8!w-ClR7RQ$~WJRZ!CB) z+P*3p&NtA<0{W;@ajY|-rjDl!v{B*jnJ`W}LAUphokc?-|G2jfjh#l9Y5KnrVRm&< z{GEbavG)qPa*9reozO#FRu7HW#sxb;VP9aKNSRn#1RQY$FWqI$=L@<9h_rJ0(jcNi z%_ZOv=^*y8VUUl+S7+RF{*46R*W9IL{p-_3;WFm`bDHIGteUn+e9B5 z;%+WvM{PKN%9hk`~(NuqEye8$BL-OzeoIhvJgHiKCa|63QFU zV-1dQ)GrSE&RDv?p$pgFH*~y`KsPr^+LJ){H){Gt0zKcz@k0W=*(hmYA{}m&a7QBD z(>MVsH#SbVvnlOroV1}Secd?W*`~ChNy5&iw6aOk2Tf^HlY~P}>9uC@NV%_B@{;EC zbaOkdUrO3xKw*nosRvro2d%l_&srxvs?v$pNzbXYTD8Bb(rw9ch+mrwA*M}j8smCJ z+upaeqc_?nJkX9lZr20Xx3*94x2KgI+Tr@Pjvl00kdkyyXSz2f>50y?GbLerXWEyN z@Lp%CNlEy;Gu_lF=~!pFuT#?EF0`wYePtK=pi|QNF7!>Oq-VO&($4l*y3hk%lY!^m zuJONirPbX=e%*~8bY5|^8~x@?dbK;P>YlK-J1yyPqk^dQz0>jd)802~GQcuA!kSx4 zMrHq+M46h5Cea+CIUTkNx=+OI6fn|lZ^Qf(mrEI1eV#}d6%YHuK3|CG-H28R)89l0 zohB0li3VD8X*kQ&>c@=Y4kJB`w~-H$5@ufPQdk# zcGJT#mZ#!4CKz{zz|Ax9$$0RUqvrz+Er%PuDDG=$S)Z6l^n9WehB3`nYw21*&D4YJX3)J*e9DtG2(XxkSs78}3WCR41G8@L;m(p+Tk- zZQ^mgx4nIJ2iy1Um319#Kek80Jslc8*U@skgX!)V%l3|(aA(JCq6bqQ)i+TojGDvXBduD)uqWd-RQ$E_Mf`Zp)N@aoK&8gw8TmC zyV`df`yTG-#ddVt~f{t4>_7}obsczl52 zx&D6xw%~w-)fdpO1DYb&{TDE{w=TF2*mhrd6P~_#(Hc>mL5DM5#SM`%PvB>m=buKj z13&(gIt9Gy7(0}Dbd~p+gvr&#ZG3_XdJrZ7);9z_D4O8@c>yi>n~1|@g#x*_SFyrQ ze^}vX+msg2rHU1o2bC@n+|XM+tz)S_%wv?*gm@wKB4K@mCk9P0`P&elUs=0b2hsV- zGF==^C7NpetDs^CwMORv!c4MN(_-q~n8$$YDXU2_U4uQ{cZg=i7;%z_UJ=$W1-&is z;B(Q2=&y=WOp6uF%Va%~A}M7k4Z`q=`)<&xa5*XoHySXrXj;MJsBO7{wkl2UG0=xf z(nAK=H+I-*zbVU^fymQTj(gV0bjh{o7Q%{?4PVygHyC>ZVkS_1s8k>^m)ACK67{f7 zp>&L|C(w@*OHB_5F(;2`KPJcmrXU7UMy%m(M8oiUCLTlc1p5X-Zp?rsp8Ce$a~;>( z(uG79ny#b4;N^Jh0t{bGuA|v4iIxldbr{4|t!z7uAsS;Xp^5rFV zq+T8Wq`+)14woy0^<_c#i0NAXhV(ZR;b+}rqGwE)-0~muhInp@xpP;xO;|_vjU5?M zYIyFTrC`ibVShr<-DoMKX(((BGrEa;MZ>OoLWu_*y0i5H>Va_)_c0Uu!lt|pzKKvd zaAEYa51|Zg{Eed=*t6DhLDMkchSCfs8f+g+qqQ`3$Ly17sgFLc6SrT3nRK}(>kY^Y zn;`|PSmhzZ^Ha12SQV3t%5V83GP;4HVBuA9hY0V({UNr4siphXR=-% zo4ngZi*E%?SIur|2)6>^XNBRuO{~VXmd{S-5uInfh}vuRPD2=DkOPzT856BAt%;H! z_)i8{uc9G5=GEUG%?UEmwpxtlnb9%Gkn8ihyR7H(e$*IzIhQ% z2!B`W;b{WwhHUV3Y0MH?ES*N&_F+l zw50~xAnokEhPY)WdcEYyOBOHnBFwfT4T9*8^DBNjngF)&n_Pp%^;84xg*}F z*uGHcxMKTW(0l`odM#aDJrKK7bX~5{cPuK5C-xE1^bn)aWyL{o3gCC%8wx$gGfZ~)GKenJWXL))?FPDDzdplUB+7!iKryR?!r5#}7r)K83y&T@ESWFN-MWZA;JK>KV}+La<(m!}$G%5|8ow2}5IC z?=Uc@wKfQiVJJ(s33O0*EBdF_CU)ZcSQib@czZfIKbJoBN7cJAT}O1CeYXNO-=*wS zP+{Hw$@ASVk3jl_70z0?Y~j@xc6bbqiL_e`7$#WYJ}|^BG0}RX3Eq*z#@2V4XwljC zLro^OqInMr+d{Ve(zqYyg40@?oMj(`6?iStwbrGA=I~r@nGz63;QTb$j~nS%LjwF8 z#-#Z?El;||M7xb$?l94JMz+}hWx5mzcbe^QTHvff!q3e~A6jU>CFy{L?y+1fN)}P{t8}Pc=tr& zV+w4?99gg0bHqb9uKUSBp1_k?yDz1vl9l|Hr77W z8D3^7(@;u-tyy$wvb=9Xi$UXJk&HIlCSsv6UlVinx;k_lydj3=y9Ing$ZsoRm(U#C z;1Bm_(#H*nd!bKQKNWb}vliFqmM`p=h1_luQ!w~!RO~-1^rC`UFzAW7E(I-fzW_Jn zy#w+`_!XiV-%>Pt{yu?95`Ok7h4zXhG~f5a@if|5NkGhxisM5Qy2#-!C|_<|hk%ygTD)332O)?4XsmZWMcUMVGQvCXk(mxNdtPO!674})+8i-n?Rcr?DG?8XF^hC zA{|Vy-?Pdbswy ziPP0T5Bk0FjpSIB0E=gGEcE6KNROnWv3#GE2!SbHETB}6i)UbS@-x;QZA|F`^^o^$ z$6>mMpY=h38CDYvq7Q`U;HP``XUszrrEfVAcHs1l3OIO=;XGNNID!E&I(ELGi5Vff z>)K=12@O0nHCd*2U}gdLgJ`jgHFroSVv+Q&!qWm42H|H#&DV-NqWQ`I z7$92}nC;xA-KZKuT&>vF8)=tft2V;BYQtNOAC=ZG!HhK6UpL}~LLA<2Y%%aR%w?a# zSj_ML;&%vI&;18@`cK-dVD@szFz{IuJ!r&W{DRSrzVfj#?JFL1F=eBt&2j&<&@C3z zaSOd+Y5kLhj#%Vu2>GpPaYLwovW{OIW4(;7^c1e260I;d_(in(3b+*v{uKttX9hI5{ip$hy$uffyNxi= z@W*wJdT(K;@pXLUzo*?Jbo@SffhiuMUg^ugcv}*;0@LTP zO#JyHkwE-qp1Vd@K@g{WgKVPGTet4B0BcksLpaoSL5` zk!~Qm!3z6hv1kMr(rVU5z?UHXCsq(OuhANIgRpi*yq!3|bue|(`hnv@``tX?$8X>P z3!;rQ)|OXZPqTQuTYZ7(m}X5k^+DyQnjndV=;n6{DVVbD zRIJ}wVWA-QOC=VU-*W6qgEe5KDg$D-7-Dg`!+_YY4AwW1fMY9+vADd`h}aj5R(yYW zhY_)#7-Ml6hP77h2S>Ews+k8X{z|@3YX`mIPQ-mdC}fHt~?ny3s~kY$ja4Zc}jmrVYG0AR`Xh zz<YQza2VU2e=5o$MD;Y-zNO{4{eo5 z8AKV2p}6)b_QeJ;iuoLhe+2QrDE3ES9vHOv&eA`Yg5eq{;AkuLOgD0F%9qX z>=^g%Ft(nCx86w2?S=8Lk*T$SxXODT|1kN+&-6CdUnmXVROnS@sQ%1>={>v$A`$Oo z|Eg%Vk!`va9$jyCBtK>^_4=^?z;#ybE(8DY10Ry)d)w4)M!G(AH{R@suN1uGyTe$l z)BNxB+sm*X>Mq%DnLoAPPo2u1tksWaXECnCnHUp2FNbcfD9Hqyd>DU0D-Uy@U%XCT3u1dJL&5bwbJA z#(CW(-fo_0{x!&EF4c+oeOWbZPjIiXS`%s;`6%^$a zmH}5dLR+@jEiDaEyg1PdR>Yj9*5TTM#t@S9bPY>-y0*MkTRBR@c@=C?ZlNk;kzVBm zmF|3X*0h2`x9XZxI<2@!d#GY*Zh>5iEZYrha??oV_Ce~>VzqcOR?ilp9o=eC?hLnD zJVjm?mlRAb-~w{7UUQ~f4X?~qxhAzRgxA^1jCIr3N_vXI!Wi;TRb09{a`@Ph1G5GX zV*(?@6|pet%Y09f*$eKB9y9#n;iCqQ0H4NWx<(8foH;}tG$ESH+QL`nc3w7CvqD7M zd({H3I@yhdy0w|hth#vk2!84=z)gwd>ohkyMsW$aja8}z`Dv=F(2WJ#s@LsSrlRQCDwq zSxKJT+qHN~*QtfYlXDBZ%9YTb5;r8FD;Aqi?VOQ_+A^RbVX0bEm}& zpQ6qwE>p3R8lAXkCWMvSAJn_KB1Oe2GJtqaRDu-w?o^pRFSkf-o9~`dPz0%(FlhLw zA>F%Yj~bmlaO~L3F6E`~ojm2qge}-ZXdK^fYxi zi&-vI2lIuAnU)L5LSlE3w+wX1w4uT{TXB&WtI*v=rG<0UGB4=mszJ_Gtd=f<8sL@0 zYFQB$POF6lMbnW0JSkRl)u|BKA~n>9AiO~0MdDPon5#Ui00d}tpH%>Klilj*A!F2; z1;rXpZyIHxk-3vF3n2;IyVO~^UX)xgbt;&Kwk|?Jc%&`WO@nrE%>g^cvL?(P%r#Ew zBvGJhX?1i?v8S|KZc#2On4jA-N^x+n?U~lEn~rlDjVsc)Sjy zM~F45J-AC3**VpYm_Upxa?kc)Wj6>7H`|~IS(#(ea@k|E#ta{IaWr|+$>$83Q|caA zQj$9-d!To$T&W(NG{n`AMv7YOA4TqrVl?fPlHwU5nh9;AQ?1h)iAj$U8&_hOnv$^GvEHrAJG=7Ijj0{h;>Yfb}83mU4d%R_Z?nu$- zN7}xa0a+KOr|Wm_6fd@EWS6Q%oz#v+9pzx-&W9l6&MufyHbeE6c|64>EX$nkq`~iG zVzjZco~qsL(E7#ucvLe#?A;q4oG z&rhboxn-~(RA|bwqUlA&voP?6_OaCWum}{ODp6@d6_AaE-5s71SY0Khb7)5Hba&mz zY;Kek*fFw_tPYu>Ob6Y=v{NNkUo11@6<`@#Bw*II3H~lB~aP=zMM$+ zlZ9(VU{J_KN6nsr?KhB3ueV;B!cTR=>dkc;s@kXZa5}wd+2{)erPP?;5n3`3MutaPgvc&!2NlAAVXJeh zN?v#26v{1`O6mnFrK;WP^grF?^yHSv`mhk9n@%mtEoDJV>E4Obz>{msatqnMgmewB zWxJjsdyh`&UPV0N;5NpdLGCy(3Yc}+HPbb;p-AtHY8z^!&Vp5ju{rWcGikkS-ZBj! zM<<0_qhy+dmjd~Ru}dj__`akqwT1{+?b5DH@HD#)Wyd6d!_&Eri~J9nNwi?2Gx&}f}o z=piAR(_&&MO{M5so>iSg#fFO0jFbOZ{|ZSn`c~+&_Nc=W2lX(eI34;oWG=yAg+^yt z-3 zBm}bu*%@;U6#IuxM!ZZG?E1Rt!L_UQ3F(rlYO$oTy{BvV$oLkv){9G$iTf3d4X7K4FsmP8E5Ed)jCaCPNK`3OP8zfqEXiUF zbF*YG)9WG|*Nb$}HX-vsPVq6xhtlGG#S}BVXl5}_3z$C`$_Kz}P@+l;CtuCvt*RGN zf0eXOgXh=JyCBMh1!3q!r4c4!s#R7}q{>~0+$(cKwk^w9vZOPj_%KGF{ElMjF;Lx#3|!VhhdlwV9Gk zr;BKP22Ux=W5nJ$*&<^5GW@)r9>R?t?XmceX%F28BXtB%q0n=gndp?5OU}qGjcOrH zuklvc0WeM30^|MLusBXPuag#C~wn;gS=}P^Xe3K09Do zZ?TmCA=6zsy3+NQ=BKB_oi(H&U(TRW3A8+?%W13opVR>%34&9hFm2j}ITxv;OQK@A z^A);h<4I~vByFhc<#LwP=;YI&0*YlMwpPRJD8?|FTUJ^O?iJ+4XuX6d*IH-9)E3w5 zID!H$aZA4;bOC1U>NJ>|aJB6J?v}tl@ve+LB{krp01V^MX9F{5y_~d z8=Ki#w_~`0#wwNrTd41Q(?UrH~Q=ZndCtcm>MEx zCbS~Prfe^!iMs2CJd?BYWFObAc+8}d;^I=wflFXZ7eY}=|F#xcRLs-eS#I|KQg&J1 zIB?Z!R3->9fkQz^$-?Oih zy-{+q#Xbj2zUT^`t?G`4;<8dN&)9M?SK!HENCT&$6GQ$nnn)*woc!d62LjkN?C6VD zyV@Kvq-%LfC_4|NR*v$RN1*T$%=q~DglIE@o0;o01=3oK1R)AQH(NUB^dXZJdM0H4 zcVxd^=mvw8b|22#kuaJu(uns|$;T^zka?Ip1!FyUJAGC*w*Xiv^T^K3CNdJjV-Zdd>)L%SgfcrD zigX$-*mBOse0&Zo9yiG=HY2k!vD2c)MXNyBqacbJ=X6udQ(Rb(HwV*ZyhWRn3K79b z&Ak`(W@TN}mE(EFl6;DMtl>_|r@wT-GdbD8`wxjkRG4j<7EBEPcw+BiRPIPE=$YFK?ECwocPsMymQ*2(0w0uI0K1b09+Pp$O z$wy0(jfoK6&lOR(eD}<5WpLQ%!=(rV3~PI!B+)IPb_

qx$Hlw8(bwUY0609QE5 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 +#include +#include +#include +#include +#include +#include +#include + +namespace py = pybind11; + + +class MCTS { + int max_moves; + int num_simulations; + double pb_c_base; + double pb_c_init; + double root_dirichlet_alpha; + double root_noise_weight; + +public: + MCTS(int max_moves=512, int num_simulations=800, + double pb_c_base=19652, double pb_c_init=1.25, + double root_dirichlet_alpha=0.3, double root_noise_weight=0.25) + : max_moves(max_moves), num_simulations(num_simulations), + pb_c_base(pb_c_base), pb_c_init(pb_c_init), + root_dirichlet_alpha(root_dirichlet_alpha), + root_noise_weight(root_noise_weight) {} + + // 包括get_next_action，_simulate，_select_child，_expand_leaf_node，_ucb_score，_add_exploration_noise + + double _ucb_score(Node* parent, Node* child) { + double pb_c = std::log((parent->visit_count + pb_c_base + 1) / pb_c_base) + pb_c_init; + pb_c *= std::sqrt(parent->visit_count) / (child->visit_count + 1); + + double prior_score = pb_c * child->prior_p; + // double value_score = child->value; + double value_score = child->get_value(); // 使用get_value()方法替代value成员 + return prior_score + value_score; + } + + void _add_exploration_noise(Node* node) { + std::vector actions; + for (const auto& kv : node->children) { + actions.push_back(kv.first); + } + + std::default_random_engine generator; + std::gamma_distribution distribution(root_dirichlet_alpha, 1.0); + + std::vector noise; + for (size_t i = 0; i < actions.size(); ++i) { + noise.push_back(distribution(generator)); + } + + double frac = root_noise_weight; + for (size_t i = 0; i < actions.size(); ++i) { + node->children[actions[i]]->prior_p = node->children[actions[i]]->prior_p * (1 - frac) + noise[i] * frac; + } + } + + // 在MCTS类中定义_select_child和_expand_leaf_node函数 + std::pair _select_child(Node* node, py::object simulate_env) { + + int action = -1; + Node* child = nullptr; + double best_score = -9999999; + for (const auto& kv : node->children) { + int action_tmp = kv.first; + Node* child_tmp = kv.second; + + // py::list legal_actions_py = simulate_env.attr("legal_actions")().cast(); + py::list legal_actions_py = simulate_env.attr("legal_actions").cast(); + + std::vector legal_actions; + for (py::handle h : legal_actions_py) { + legal_actions.push_back(h.cast()); + } + + if (std::find(legal_actions.begin(), legal_actions.end(), action_tmp) != legal_actions.end()) { + double score = _ucb_score(node, child_tmp); + if (score > best_score) { + best_score = score; + action = action_tmp; + child = child_tmp; + } + } + + } + if (child == nullptr) { + child = node; + } + return std::make_pair(action, child); + } + + double _expand_leaf_node(Node* node, py::object simulate_env, py::object policy_forward_fn) { + // std::cout << "position11 " << std::endl; + + std::map action_probs_dict; + double leaf_value; + // std::cout << "position12 " << std::endl; + py::tuple result = policy_forward_fn(simulate_env); + // std::cout << "position13 " << std::endl; + + action_probs_dict = result[0].cast>(); + leaf_value = result[1].cast(); + + // 获取 legal_actions 属性的值，并将其转换为一个 std::vector + // std::cout << "position14 " << std::endl; + + py::list legal_actions_list = simulate_env.attr("legal_actions").cast(); + std::vector legal_actions = legal_actions_list.cast>(); + + // only for debug + // auto legal_actions_pyobj = simulate_env.attr("legal_actions_func")(); + // std::cout << "position15 " << std::endl; + // if (!py::isinstance(legal_actions_pyobj)) { + // throw std::runtime_error("legal_actions did not return an iterable object"); + // } + // py::list legal_actions_list = legal_actions_pyobj.cast(); + // std::vector legal_actions; + // for (auto item : legal_actions_list) { + // if (py::isinstance(item)) { + // legal_actions.push_back(item.cast()); + // } else { + // throw std::runtime_error("Non-integer item in legal_actions list"); + // } + // } + + // std::cout << "position16 " << std::endl; + + for (const auto& kv : action_probs_dict) { + // std::cout << "position17 " << std::endl; + + int action = kv.first; + double prior_p = kv.second; + if (std::find(legal_actions.begin(), legal_actions.end(), action) != legal_actions.end()) { + node->children[action] = new Node(node, prior_p); + } + } + // std::cout << "position18 " << std::endl; + + return leaf_value; + } + + std::pair> get_next_action(py::object simulate_env, py::object policy_forward_fn, double temperature, bool sample) { + // std::cout << "position1 " << std::endl; + Node* root = new Node(); + // std::cout << "position2 " << std::endl; + _expand_leaf_node(root, simulate_env, policy_forward_fn); + // std::cout << "position3 " << std::endl; + + if (sample) { + // std::cout << "position4 " << std::endl; + _add_exploration_noise(root); + // std::cout << "position5 " << std::endl; + + } + // std::cout << "position6 " << std::endl; + + for (int n = 0; n < num_simulations; ++n) { + // std::cout << "position7 " << std::endl; + py::object simulate_env_copy = simulate_env.attr("clone")(); + // std::cout << "position8 " << std::endl; + _simulate(root, simulate_env_copy, policy_forward_fn); + // std::cout << "position9 " << std::endl; + simulate_env_copy = py::none(); + // std::cout << "position10 " << std::endl; + } + + std::vector> action_visits; + // std::cout << "position11 " << std::endl; + for (int action = 0; action < simulate_env.attr("action_space").attr("n").cast(); ++action) { + if (root->children.count(action)) { + // std::cout << "position12 " << std::endl; + + action_visits.push_back(std::make_pair(action, root->children[action]->visit_count)); + } else { + // std::cout << "position13 " << std::endl; + + action_visits.push_back(std::make_pair(action, 0)); + } + } + + // 转换action_visits为两个分离的数组 + std::vector actions; + std::vector visits; + // std::cout << "position14 " << std::endl; + + for (const auto& av : action_visits) { + actions.push_back(av.first); + visits.push_back(av.second); + } + + // 计算action_probs + std::vector visit_logs; + for (int v : visits) { + visit_logs.push_back(std::log(v + 1e-10)); + } + std::vector action_probs = softmax(visit_logs, temperature); + // std::cout << "position15 " << std::endl; + + // 根据action_probs选择一个action + int action; + if (sample) { + action = random_choice(actions, action_probs); + } else { + action = actions[std::distance(action_probs.begin(), std::max_element(action_probs.begin(), action_probs.end()))]; + } + // std::cout << "position16 " << std::endl; + + return std::make_pair(action, action_probs); + } + + void _simulate(Node* node, py::object simulate_env, py::object policy_forward_fn) { + // std::cout << "position21 " << std::endl; + + while (!node->is_leaf()) { + int action; + std::tie(action, node) = _select_child(node, simulate_env); + if (action == -1) { + break; + } + simulate_env.attr("step")(action); + } + + bool done; + int winner; + // std::tie(done, winner) = simulate_env.attr("get_done_winner")(); + py::tuple result = simulate_env.attr("get_done_winner")(); + done = result[0].cast(); + winner = result[1].cast(); + + double leaf_value; + // std::cout << "position22 " << std::endl; + + if (!done) { + leaf_value = _expand_leaf_node(node, simulate_env, policy_forward_fn); + // std::cout << "position23 " << std::endl; + } + else { + // if (simulate_env.attr("mcts_mode") == "self_play_mode") { + if (simulate_env.attr("mcts_mode").cast() == "self_play_mode") { // 使用get_mcts_mode()方法替代mcts_mode成员 + // std::cout << "position24 " << std::endl; + + if (winner == -1) { + leaf_value = 0; + } else { + leaf_value = (simulate_env.attr("current_player").cast() == winner) ? 1 : -1; + } + } + else if (simulate_env.attr("mcts_mode").cast() == "play_with_bot_mode") { // 使用get_mcts_mode()方法替代mcts_mode成员 + if (winner == -1) { + leaf_value = 0; + } else if (winner == 1) { + leaf_value = 1; + } else if (winner == 2) { + leaf_value = -1; + } + } + } + // std::cout << "position25 " << std::endl; + + // if (simulate_env.attr("mcts_mode") == "play_with_bot_mode") { + if (simulate_env.attr("mcts_mode").cast() == "play_with_bot_mode") { + node->update_recursive(leaf_value, simulate_env.attr("mcts_mode").cast()); + } else if (simulate_env.attr("mcts_mode").cast() == "self_play_mode") { + node->update_recursive(-leaf_value, simulate_env.attr("mcts_mode").cast()); + } + } + +private: + static std::vector softmax(const std::vector& values, double temperature) { + std::vector exps; + double sum = 0.0; + for (double v : values) { + double exp_v = std::exp(v / temperature); + exps.push_back(exp_v); + sum += exp_v; + } + for (double& exp_v : exps) { + exp_v /= sum; + } + return exps; + } + + static int random_choice(const std::vector& actions, const std::vector& probs) { + std::random_device rd; + std::mt19937 gen(rd()); + std::discrete_distribution<> d(probs.begin(), probs.end()); + return actions[d(gen)]; + } + +}; + +PYBIND11_MODULE(mcts_alphazero, m) { + py::class_(m, "Node") + // .def(py::init()) + .def(py::init([](Node* parent, float prior_p){ + return new Node(parent ? parent : nullptr, prior_p); + }), py::arg("parent")=nullptr, py::arg("prior_p")=1.0) + .def("value", &Node::get_value) + .def("update", &Node::update) + .def("update_recursive", &Node::update_recursive) + .def("is_leaf", &Node::is_leaf) + .def("is_root", &Node::is_root) + .def("parent", &Node::get_parent) + // .def("children", &Node::get_children) + .def_readwrite("children", &Node::children) + .def("visit_count", &Node::get_visit_count); + + py::class_(m, "MCTS") + .def(py::init(), + py::arg("max_moves")=512, py::arg("num_simulations")=800, + py::arg("pb_c_base")=19652, py::arg("pb_c_init")=1.25, + py::arg("root_dirichlet_alpha")=0.3, py::arg("root_noise_weight")=0.25) + .def("_ucb_score", &MCTS::_ucb_score) + .def("_add_exploration_noise", &MCTS::_add_exploration_noise) + .def("_select_child", &MCTS::_select_child) + .def("_expand_leaf_node", &MCTS::_expand_leaf_node) + // .def("get_next_action", &MCTS::get_next_action, + // py::arg("simulate_env"), py::arg("policy_forward_fn"), + // py::arg("temperature")=1.0, py::arg("sample")=true) + .def("get_next_action", &MCTS::get_next_action) + .def("_simulate", &MCTS::_simulate); +} + + +// 构建与编译命令 +// mkdir build +// cd buld +// cmake .. +// make \ No newline at end of file diff --git a/lzero/mcts/ctree/ctree_alphazero/mcts_alphazero_nopy.cpp b/lzero/mcts/ctree/ctree_alphazero/mcts_alphazero_nopy.cpp new file mode 100644 index 000000000..789932a33 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/mcts_alphazero_nopy.cpp @@ -0,0 +1,299 @@ +#include "node_alphazero.h" +#include +#include +#include +#include +#include +#include +#include + +namespace py = pybind11; + + +// struct Node { +// Node* parent; +// std::map children; +// double prior_p; +// double value; +// int visit_count; + +// Node(Node* parent=nullptr, double prior_p=0.0) +// : parent(parent), prior_p(prior_p), value(0.0), visit_count(0) {} + +// virtual bool is_leaf() const = 0; +// virtual void update_recursive(double leaf_value) = 0; +// virtual ~Node() = default; // 添加虚析构函数 +// }; + + +// 模拟环境类和策略函数类的定义 +class ActionSpace { // 在SimulateEnv类之前定义ActionSpace类 +public: + virtual int n() const = 0; +}; + + +class SimulateEnv { + public: + std::string mcts_mode; // 添加mcts_mode成员变量 + virtual std::vector legal_actions() const = 0; + virtual void step(int action) = 0; + virtual std::pair get_done_winner() const = 0; + + virtual SimulateEnv* clone() const = 0; // 新增一个clone方法，用于替代Python的copy.deepcopy + virtual int get_current_player() const = 0; // 添加get_current_player方法 + const std::string& get_mcts_mode() const { return mcts_mode; } // 添加get_mcts_mode方法 + virtual ~SimulateEnv() = default; // 添加虚析构函数 + virtual ActionSpace* action_space() const = 0; +}; + +class PolicyFunction { + public: + virtual std::pair, double> operator()(SimulateEnv*) const = 0; +}; + + + +class MCTS { + int max_moves; + int num_simulations; + double pb_c_base; + double pb_c_init; + double root_dirichlet_alpha; + double root_noise_weight; + +public: + MCTS(int max_moves=512, int num_simulations=800, + double pb_c_base=19652, double pb_c_init=1.25, + double root_dirichlet_alpha=0.3, double root_noise_weight=0.25) + : max_moves(max_moves), num_simulations(num_simulations), + pb_c_base(pb_c_base), pb_c_init(pb_c_init), + root_dirichlet_alpha(root_dirichlet_alpha), + root_noise_weight(root_noise_weight) {} + + // 包括get_next_action，_simulate，_select_child，_expand_leaf_node，_ucb_score，_add_exploration_noise + + double _ucb_score(Node* parent, Node* child) { + double pb_c = std::log((parent->visit_count + pb_c_base + 1) / pb_c_base) + pb_c_init; + pb_c *= std::sqrt(parent->visit_count) / (child->visit_count + 1); + + double prior_score = pb_c * child->prior_p; + // double value_score = child->value; + double value_score = child->get_value(); // 使用get_value()方法替代value成员 + return prior_score + value_score; + } + + void _add_exploration_noise(Node* node) { + std::vector actions; + for (const auto& kv : node->children) { + actions.push_back(kv.first); + } + + std::default_random_engine generator; + std::gamma_distribution distribution(root_dirichlet_alpha, 1.0); + + std::vector noise; + for (size_t i = 0; i < actions.size(); ++i) { + noise.push_back(distribution(generator)); + } + + double frac = root_noise_weight; + for (size_t i = 0; i < actions.size(); ++i) { + node->children[actions[i]]->prior_p = node->children[actions[i]]->prior_p * (1 - frac) + noise[i] * frac; + } + } + + // 在MCTS类中定义_select_child和_expand_leaf_node函数 + std::pair _select_child(Node* node, SimulateEnv* simulate_env) { + int action = -1; + Node* child = nullptr; + double best_score = -9999999; + for (const auto& kv : node->children) { + int action_tmp = kv.first; + Node* child_tmp = kv.second; + if (std::find(simulate_env->legal_actions().begin(), + simulate_env->legal_actions().end(), + action_tmp) != simulate_env->legal_actions().end()) { + double score = _ucb_score(node, child_tmp); + if (score > best_score) { + best_score = score; + action = action_tmp; + child = child_tmp; + } + } + } + if (child == nullptr) { + child = node; + } + return std::make_pair(action, child); + } + + double _expand_leaf_node(Node* node, SimulateEnv* simulate_env, const PolicyFunction& policy_forward_fn) { + std::map action_probs_dict; + double leaf_value; + std::tie(action_probs_dict, leaf_value) = policy_forward_fn(simulate_env); + for (const auto& kv : action_probs_dict) { + int action = kv.first; + double prior_p = kv.second; + if (std::find(simulate_env->legal_actions().begin(), + simulate_env->legal_actions().end(), + action) != simulate_env->legal_actions().end()) { + node->children[action] = new Node(node, prior_p); + } + } + return leaf_value; + } + + std::pair> get_next_action(SimulateEnv* simulate_env, const PolicyFunction& policy_forward_fn, double temperature=1.0, bool sample=true) { + Node* root = new Node(); + _expand_leaf_node(root, simulate_env, policy_forward_fn); + if (sample) { + _add_exploration_noise(root); + } + + for (int n = 0; n < num_simulations; ++n) { + SimulateEnv* simulate_env_copy = simulate_env->clone(); + _simulate(root, simulate_env_copy, policy_forward_fn); + delete simulate_env_copy; + } + + std::vector> action_visits; + for (int action = 0; action < simulate_env->action_space()->n(); ++action) { + if (root->children.count(action)) { + action_visits.push_back(std::make_pair(action, root->children[action]->visit_count)); + } else { + action_visits.push_back(std::make_pair(action, 0)); + } + } + + // 转换action_visits为两个分离的数组 + std::vector actions; + std::vector visits; + for (const auto& av : action_visits) { + actions.push_back(av.first); + visits.push_back(av.second); + } + + // 计算action_probs + std::vector visit_logs; + for (int v : visits) { + visit_logs.push_back(std::log(v + 1e-10)); + } + std::vector action_probs = softmax(visit_logs, temperature); + + // 根据action_probs选择一个action + int action; + if (sample) { + action = random_choice(actions, action_probs); + } else { + action = actions[std::distance(action_probs.begin(), std::max_element(action_probs.begin(), action_probs.end()))]; + } + + return std::make_pair(action, action_probs); + } + + void _simulate(Node* node, SimulateEnv* simulate_env, const PolicyFunction& policy_forward_fn) { + while (!node->is_leaf()) { + int action; + std::tie(action, node) = _select_child(node, simulate_env); + if (action == -1) { + break; + } + simulate_env->step(action); + } + + bool done; + int winner; + std::tie(done, winner) = simulate_env->get_done_winner(); + + double leaf_value; + if (!done) { + leaf_value = _expand_leaf_node(node, simulate_env, policy_forward_fn); + } else { + // if (simulate_env->mcts_mode == "self_play_mode") { + if (simulate_env->get_mcts_mode() == "self_play_mode") { // 使用get_mcts_mode()方法替代mcts_mode成员 + if (winner == -1) { + leaf_value = 0; + } else { + leaf_value = (simulate_env->get_current_player() == winner) ? 1 : -1; + } + } + // else if (simulate_env->mcts_mode == "play_with_bot_mode") { + else if (simulate_env->get_mcts_mode() == "play_with_bot_mode") { // 使用get_mcts_mode()方法替代mcts_mode成员 + if (winner == -1) { + leaf_value = 0; + } else if (winner == 1) { + leaf_value = 1; + } else if (winner == 2) { + leaf_value = -1; + } + } + } + + if (simulate_env->mcts_mode == "play_with_bot_mode") { + node->update_recursive(leaf_value, simulate_env->mcts_mode); + } else if (simulate_env->mcts_mode == "self_play_mode") { + node->update_recursive(-leaf_value, simulate_env->mcts_mode); + } + } + +private: + static std::vector softmax(const std::vector& values, double temperature) { + std::vector exps; + double sum = 0.0; + for (double v : values) { + double exp_v = std::exp(v / temperature); + exps.push_back(exp_v); + sum += exp_v; + } + for (double& exp_v : exps) { + exp_v /= sum; + } + return exps; + } + + static int random_choice(const std::vector& actions, const std::vector& probs) { + std::random_device rd; + std::mt19937 gen(rd()); + std::discrete_distribution<> d(probs.begin(), probs.end()); + return actions[d(gen)]; + } + +}; + +PYBIND11_MODULE(mcts_alphazero, m) { + // py::class_(m, "Node") + // .def(py::init(), + // py::arg("parent")=nullptr, py::arg("prior_p")=0.0) + // .def("is_leaf", &Node::is_leaf) + // .def("update_recursive", &Node::update_recursive); + + py::class_(m, "Node") + // .def(py::init()) + .def(py::init([](Node* parent, float prior_p){ + return new Node(parent ? parent : nullptr, prior_p); + }), py::arg("parent")=nullptr, py::arg("prior_p")=1.0) + .def("value", &Node::get_value) + .def("update", &Node::update) + .def("update_recursive", &Node::update_recursive) + .def("is_leaf", &Node::is_leaf) + .def("is_root", &Node::is_root) + .def("parent", &Node::get_parent) + // .def("children", &Node::get_children) + .def_readwrite("children", &Node::children) + .def("visit_count", &Node::get_visit_count); + + py::class_(m, "MCTS") + .def(py::init(), + py::arg("max_moves")=512, py::arg("num_simulations")=800, + py::arg("pb_c_base")=19652, py::arg("pb_c_init")=1.25, + py::arg("root_dirichlet_alpha")=0.3, py::arg("root_noise_weight")=0.25) + .def("_ucb_score", &MCTS::_ucb_score) + .def("_add_exploration_noise", &MCTS::_add_exploration_noise) + .def("_select_child", &MCTS::_select_child) + .def("_expand_leaf_node", &MCTS::_expand_leaf_node) + .def("get_next_action", &MCTS::get_next_action, + py::arg("simulate_env"), py::arg("policy_forward_fn"), + py::arg("temperature")=1.0, py::arg("sample")=true) + .def("_simulate", &MCTS::_simulate); +} \ No newline at end of file diff --git a/lzero/mcts/ctree/ctree_alphazero/node_alphazero.cpp b/lzero/mcts/ctree/ctree_alphazero/node_alphazero.cpp new file mode 100644 index 000000000..77731a788 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/node_alphazero.cpp @@ -0,0 +1,29 @@ +#include "node_alphazero.h" +#include +#include + +namespace py = pybind11; + +PYBIND11_MODULE(node_alphazero, m) { + py::class_(m, "Node") + // .def(py::init()) + .def(py::init([](Node* parent, float prior_p){ + return new Node(parent ? parent : nullptr, prior_p); + }), py::arg("parent")=nullptr, py::arg("prior_p")=1.0) + .def("value", &Node::get_value) + .def("update", &Node::update) + .def("update_recursive", &Node::update_recursive) + .def("is_leaf", &Node::is_leaf) + .def("is_root", &Node::is_root) + .def("parent", &Node::get_parent) + // .def("children", &Node::get_children) + .def_readwrite("children", &Node::children) + .def("visit_count", &Node::get_visit_count); +} + + +// 构建与编译命令 +// mkdir build +// cd buld +// cmake .. +// make \ No newline at end of file diff --git a/lzero/mcts/ctree/ctree_alphazero/node_alphazero.h b/lzero/mcts/ctree/ctree_alphazero/node_alphazero.h new file mode 100644 index 000000000..38654ce49 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/node_alphazero.h @@ -0,0 +1,63 @@ +#include +#include + +class Node { +public: + Node(Node* parent = nullptr, float prior_p = 1.0) + : parent(parent), prior_p(prior_p), visit_count(0), value_sum(0.0) {} + + float get_value() { + return visit_count == 0 ? 0.0 : value_sum / visit_count; + } + + void update(float value) { + visit_count++; + value_sum += value; + } + + void update_recursive(float leaf_value, std::string mcts_mode) { + update(leaf_value); + if (!is_root()) { + if (mcts_mode == "self_play_mode") { + parent->update_recursive(-leaf_value, mcts_mode); + } + else if (mcts_mode == "play_with_bot_mode") { + parent->update_recursive(leaf_value, mcts_mode); + } + } + } + + bool is_leaf() { + return children.empty(); + } + + bool is_root() { + return parent == nullptr; + } + + Node* get_parent() { + return parent; + } + + std::map get_children() { + return children; + } + + int get_visit_count() { + return visit_count; + } + +public: + Node* parent; + float prior_p; + int visit_count; + float value_sum; + std::map children; // or std::vector + +// private: +// Node* _parent; +// float _prior_p; +// int _visit_count; +// float _value_sum; +// std::map _children; +}; \ No newline at end of file diff --git a/lzero/mcts/ctree/ctree_alphazero/node_alphazero_bkp.cpp b/lzero/mcts/ctree/ctree_alphazero/node_alphazero_bkp.cpp new file mode 100644 index 000000000..afe3dd0c4 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/node_alphazero_bkp.cpp @@ -0,0 +1,89 @@ +#include +#include +#include // Add this line +namespace py = pybind11; + +class Node { +public: + Node(Node* parent = nullptr, float prior_p = 1.0) + : parent(parent), prior_p(prior_p), visit_count(0), value_sum(0.0) {} + + float get_value() { + return visit_count == 0 ? 0.0 : value_sum / visit_count; + } + + void update(float value) { + visit_count++; + value_sum += value; + } + + void update_recursive(float leaf_value, std::string mcts_mode) { + update(leaf_value); + if (!is_root()) { + if (mcts_mode == "self_play_mode") { + parent->update_recursive(-leaf_value, mcts_mode); + } + else if (mcts_mode == "play_with_bot_mode") { + parent->update_recursive(leaf_value, mcts_mode); + } + } + } + + bool is_leaf() { + return children.empty(); + } + + bool is_root() { + return parent == nullptr; + } + + Node* get_parent() { + return parent; + } + + std::map get_children() { + return children; + } + + int get_visit_count() { + return visit_count; + } + +public: + Node* parent; + float prior_p; + int visit_count; + float value_sum; + std::map children; // or std::vector + +// private: +// Node* _parent; +// float _prior_p; +// int _visit_count; +// float _value_sum; +// std::map _children; +}; + +PYBIND11_MODULE(node_alphazero, m) { + py::class_(m, "Node") + // .def(py::init()) + .def(py::init([](Node* parent, float prior_p){ + return new Node(parent ? parent : nullptr, prior_p); + }), py::arg("parent")=nullptr, py::arg("prior_p")=1.0) + .def("value", &Node::get_value) + .def("update", &Node::update) + .def("update_recursive", &Node::update_recursive) + .def("is_leaf", &Node::is_leaf) + .def("is_root", &Node::is_root) + .def("parent", &Node::get_parent) + // .def("children", &Node::get_children) + .def_readwrite("children", &Node::children) + .def("visit_count", &Node::get_visit_count); +} + + +// 构建与编译命令 +// mkdir build +// cd buld +// cmake .. +// make \ No newline at end of file diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.appveyor.yml b/lzero/mcts/ctree/ctree_alphazero/pybind11/.appveyor.yml new file mode 100644 index 000000000..360760ac8 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.appveyor.yml @@ -0,0 +1,35 @@ +version: 1.0.{build} +image: +- Visual Studio 2017 +test: off +skip_branch_with_pr: true +build: + parallel: true +platform: +- x86 +environment: + matrix: + - PYTHON: 36 + CONFIG: Debug +install: +- ps: | + $env:CMAKE_GENERATOR = "Visual Studio 15 2017" + if ($env:PLATFORM -eq "x64") { $env:PYTHON = "$env:PYTHON-x64" } + $env:PATH = "C:\Python$env:PYTHON\;C:\Python$env:PYTHON\Scripts\;$env:PATH" + python -W ignore -m pip install --upgrade pip wheel + python -W ignore -m pip install pytest numpy --no-warn-script-location pytest-timeout +- ps: | + Start-FileDownload 'https://gitlab.com/libeigen/eigen/-/archive/3.3.7/eigen-3.3.7.zip' + 7z x eigen-3.3.7.zip -y > $null + $env:CMAKE_INCLUDE_PATH = "eigen-3.3.7;$env:CMAKE_INCLUDE_PATH" +build_script: +- cmake -G "%CMAKE_GENERATOR%" -A "%CMAKE_ARCH%" + -DCMAKE_CXX_STANDARD=14 + -DPYBIND11_WERROR=ON + -DDOWNLOAD_CATCH=ON + -DCMAKE_SUPPRESS_REGENERATION=1 + . +- set MSBuildLogger="C:\Program Files\AppVeyor\BuildAgent\Appveyor.MSBuildLogger.dll" +- cmake --build . --config %CONFIG% --target pytest -- /m /v:m /logger:%MSBuildLogger% +- cmake --build . --config %CONFIG% --target cpptest -- /m /v:m /logger:%MSBuildLogger% +on_failure: if exist "tests\test_cmake_build" type tests\test_cmake_build\*.log* diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.clang-format b/lzero/mcts/ctree/ctree_alphazero/pybind11/.clang-format new file mode 100644 index 000000000..b477a1603 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.clang-format @@ -0,0 +1,38 @@ +--- +# See all possible options and defaults with: +# clang-format --style=llvm --dump-config +BasedOnStyle: LLVM +AccessModifierOffset: -4 +AllowShortLambdasOnASingleLine: true +AlwaysBreakTemplateDeclarations: Yes +BinPackArguments: false +BinPackParameters: false +BreakBeforeBinaryOperators: All +BreakConstructorInitializers: BeforeColon +ColumnLimit: 99 +CommentPragmas: 'NOLINT:.*|^ IWYU pragma:' +IncludeBlocks: Regroup +IndentCaseLabels: true +IndentPPDirectives: AfterHash +IndentWidth: 4 +Language: Cpp +SpaceAfterCStyleCast: true +Standard: Cpp11 +StatementMacros: ['PyObject_HEAD'] +TabWidth: 4 +IncludeCategories: + - Regex: '' + Priority: 4 + - Regex: '.*' + Priority: 5 +... diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.clang-tidy b/lzero/mcts/ctree/ctree_alphazero/pybind11/.clang-tidy new file mode 100644 index 000000000..23018386c --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.clang-tidy @@ -0,0 +1,77 @@ +FormatStyle: file + +Checks: | + *bugprone*, + *performance*, + clang-analyzer-optin.cplusplus.VirtualCall, + clang-analyzer-optin.performance.Padding, + cppcoreguidelines-init-variables, + cppcoreguidelines-prefer-member-initializer, + cppcoreguidelines-pro-type-static-cast-downcast, + cppcoreguidelines-slicing, + google-explicit-constructor, + llvm-namespace-comment, + misc-definitions-in-headers, + misc-misplaced-const, + misc-non-copyable-objects, + misc-static-assert, + misc-throw-by-value-catch-by-reference, + misc-uniqueptr-reset-release, + misc-unused-parameters, + modernize-avoid-bind, + modernize-loop-convert, + modernize-make-shared, + modernize-redundant-void-arg, + modernize-replace-auto-ptr, + modernize-replace-disallow-copy-and-assign-macro, + modernize-replace-random-shuffle, + modernize-shrink-to-fit, + modernize-use-auto, + modernize-use-bool-literals, + modernize-use-default-member-init, + modernize-use-emplace, + modernize-use-equals-default, + modernize-use-equals-delete, + modernize-use-noexcept, + modernize-use-nullptr, + modernize-use-override, + modernize-use-using, + readability-avoid-const-params-in-decls, + readability-braces-around-statements, + readability-const-return-type, + readability-container-size-empty, + readability-delete-null-pointer, + readability-else-after-return, + readability-implicit-bool-conversion, + readability-inconsistent-declaration-parameter-name, + readability-make-member-function-const, + readability-misplaced-array-index, + readability-non-const-parameter, + readability-qualified-auto, + readability-redundant-function-ptr-dereference, + readability-redundant-smartptr-get, + readability-redundant-string-cstr, + readability-simplify-subscript-expr, + readability-static-accessed-through-instance, + readability-static-definition-in-anonymous-namespace, + readability-string-compare, + readability-suspicious-call-argument, + readability-uniqueptr-delete-release, + -bugprone-easily-swappable-parameters, + -bugprone-exception-escape, + -bugprone-reserved-identifier, + -bugprone-unused-raii, + +CheckOptions: +- key: modernize-use-equals-default.IgnoreMacros + value: false +- key: performance-for-range-copy.WarnOnAllAutoCopies + value: true +- key: performance-inefficient-string-concatenation.StrictMode + value: true +- key: performance-unnecessary-value-param.AllowedTypes + value: 'exception_ptr$;' +- key: readability-implicit-bool-conversion.AllowPointerConditions + value: true + +HeaderFilterRegex: 'pybind11/.*h' diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.cmake-format.yaml b/lzero/mcts/ctree/ctree_alphazero/pybind11/.cmake-format.yaml new file mode 100644 index 000000000..a2a69f3f8 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.cmake-format.yaml @@ -0,0 +1,73 @@ +parse: + additional_commands: + pybind11_add_module: + flags: + - THIN_LTO + - MODULE + - SHARED + - NO_EXTRAS + - EXCLUDE_FROM_ALL + - SYSTEM + +format: + line_width: 99 + tab_size: 2 + + # If an argument group contains more than this many sub-groups + # (parg or kwarg groups) then force it to a vertical layout. + max_subgroups_hwrap: 2 + + # If a positional argument group contains more than this many + # arguments, then force it to a vertical layout. + max_pargs_hwrap: 6 + + # If a cmdline positional group consumes more than this many + # lines without nesting, then invalidate the layout (and nest) + max_rows_cmdline: 2 + separate_ctrl_name_with_space: false + separate_fn_name_with_space: false + dangle_parens: false + + # If the trailing parenthesis must be 'dangled' on its on + # 'line, then align it to this reference: `prefix`: the start' + # 'of the statement, `prefix-indent`: the start of the' + # 'statement, plus one indentation level, `child`: align to' + # the column of the arguments + dangle_align: prefix + # If the statement spelling length (including space and + # parenthesis) is smaller than this amount, then force reject + # nested layouts. + min_prefix_chars: 4 + + # If the statement spelling length (including space and + # parenthesis) is larger than the tab width by more than this + # amount, then force reject un-nested layouts. + max_prefix_chars: 10 + + # If a candidate layout is wrapped horizontally but it exceeds + # this many lines, then reject the layout. + max_lines_hwrap: 2 + + line_ending: unix + + # Format command names consistently as 'lower' or 'upper' case + command_case: canonical + + # Format keywords consistently as 'lower' or 'upper' case + # unchanged is valid too + keyword_case: 'upper' + + # A list of command names which should always be wrapped + always_wrap: [] + + # If true, the argument lists which are known to be sortable + # will be sorted lexicographically + enable_sort: true + + # If true, the parsers may infer whether or not an argument + # list is sortable (without annotation). + autosort: false + +# Causes a few issues - can be solved later, possibly. +markup: + enable_markup: false diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.codespell-ignore-lines b/lzero/mcts/ctree/ctree_alphazero/pybind11/.codespell-ignore-lines new file mode 100644 index 000000000..2a01d63eb --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.codespell-ignore-lines @@ -0,0 +1,24 @@ +template + template + auto &this_ = static_cast(*this); + if (load_impl(temp, false)) { + ssize_t nd = 0; + auto trivial = broadcast(buffers, nd, shape); + auto ndim = (size_t) nd; + int nd; + ssize_t ndim() const { return detail::array_proxy(m_ptr)->nd; } + using op = op_impl; +template + template + class_ &def(const detail::op_ &op, const Extra &...extra) { + class_ &def_cast(const detail::op_ &op, const Extra &...extra) { +@pytest.mark.parametrize("access", ["ro", "rw", "static_ro", "static_rw"]) +struct IntStruct { + explicit IntStruct(int v) : value(v){}; + ~IntStruct() { value = -value; } + IntStruct(const IntStruct &) = default; + IntStruct &operator=(const IntStruct &) = default; + py::class_(m, "IntStruct").def(py::init([](const int i) { return IntStruct(i); })); + py::implicitly_convertible(); + m.def("test", [](int expected, const IntStruct &in) { + [](int expected, const IntStruct &in) { diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.gitattributes b/lzero/mcts/ctree/ctree_alphazero/pybind11/.gitattributes new file mode 100644 index 000000000..d611e1496 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.gitattributes @@ -0,0 +1 @@ +docs/*.svg binary diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/CODEOWNERS b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/CODEOWNERS new file mode 100644 index 000000000..4e2c66902 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/CODEOWNERS @@ -0,0 +1,9 @@ +*.cmake @henryiii +CMakeLists.txt @henryiii +*.yml @henryiii +*.yaml @henryiii +/tools/ @henryiii +/pybind11/ @henryiii +noxfile.py @henryiii +.clang-format @henryiii +.clang-tidy @henryiii diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/CONTRIBUTING.md b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/CONTRIBUTING.md new file mode 100644 index 000000000..ad7974395 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/CONTRIBUTING.md @@ -0,0 +1,388 @@ +Thank you for your interest in this project! Please refer to the following +sections on how to contribute code and bug reports. + +### Reporting bugs + +Before submitting a question or bug report, please take a moment of your time +and ensure that your issue isn't already discussed in the project documentation +provided at [pybind11.readthedocs.org][] or in the [issue tracker][]. You can +also check [gitter][] to see if it came up before. + +Assuming that you have identified a previously unknown problem or an important +question, it's essential that you submit a self-contained and minimal piece of +code that reproduces the problem. In other words: no external dependencies, +isolate the function(s) that cause breakage, submit matched and complete C++ +and Python snippets that can be easily compiled and run in isolation; or +ideally make a small PR with a failing test case that can be used as a starting +point. + +## Pull requests + +Contributions are submitted, reviewed, and accepted using GitHub pull requests. +Please refer to [this article][using pull requests] for details and adhere to +the following rules to make the process as smooth as possible: + +* Make a new branch for every feature you're working on. +* Make small and clean pull requests that are easy to review but make sure they + do add value by themselves. +* Add tests for any new functionality and run the test suite (`cmake --build + build --target pytest`) to ensure that no existing features break. +* Please run [`pre-commit`][pre-commit] to check your code matches the + project style. (Note that `gawk` is required.) Use `pre-commit run + --all-files` before committing (or use installed-mode, check pre-commit docs) + to verify your code passes before pushing to save time. +* This project has a strong focus on providing general solutions using a + minimal amount of code, thus small pull requests are greatly preferred. + +### Licensing of contributions + +pybind11 is provided under a BSD-style license that can be found in the +``LICENSE`` file. By using, distributing, or contributing to this project, you +agree to the terms and conditions of this license. + +You are under no obligation whatsoever to provide any bug fixes, patches, or +upgrades to the features, functionality or performance of the source code +("Enhancements") to anyone; however, if you choose to make your Enhancements +available either publicly, or directly to the author of this software, without +imposing a separate written license agreement for such Enhancements, then you +hereby grant the following license: a non-exclusive, royalty-free perpetual +license to install, use, modify, prepare derivative works, incorporate into +other computer software, distribute, and sublicense such enhancements or +derivative works thereof, in binary and source code form. + + +## Development of pybind11 + +### Quick setup + +To setup a quick development environment, use [`nox`](https://nox.thea.codes). +This will allow you to do some common tasks with minimal setup effort, but will +take more time to run and be less flexible than a full development environment. +If you use [`pipx run nox`](https://pipx.pypa.io), you don't even need to +install `nox`. Examples: + +```bash +# List all available sessions +nox -l + +# Run linters +nox -s lint + +# Run tests on Python 3.9 +nox -s tests-3.9 + +# Build and preview docs +nox -s docs -- serve + +# Build SDists and wheels +nox -s build +``` + +### Full setup + +To setup an ideal development environment, run the following commands on a +system with CMake 3.14+: + +```bash +python3 -m venv venv +source venv/bin/activate +pip install -r tests/requirements.txt +cmake -S . -B build -DDOWNLOAD_CATCH=ON -DDOWNLOAD_EIGEN=ON +cmake --build build -j4 +``` + +Tips: + +* You can use `virtualenv` (faster, from PyPI) instead of `venv`. +* You can select any name for your environment folder; if it contains "env" it + will be ignored by git. +* If you don't have CMake 3.14+, just add "cmake" to the pip install command. +* You can use `-DPYBIND11_FINDPYTHON=ON` to use FindPython on CMake 3.12+ +* In classic mode, you may need to set `-DPYTHON_EXECUTABLE=/path/to/python`. + FindPython uses `-DPython_ROOT_DIR=/path/to` or + `-DPython_EXECUTABLE=/path/to/python`. + +### Configuration options + +In CMake, configuration options are given with "-D". Options are stored in the +build directory, in the `CMakeCache.txt` file, so they are remembered for each +build directory. Two selections are special - the generator, given with `-G`, +and the compiler, which is selected based on environment variables `CXX` and +similar, or `-DCMAKE_CXX_COMPILER=`. Unlike the others, these cannot be changed +after the initial run. + +The valid options are: + +* `-DCMAKE_BUILD_TYPE`: Release, Debug, MinSizeRel, RelWithDebInfo +* `-DPYBIND11_FINDPYTHON=ON`: Use CMake 3.12+'s FindPython instead of the + classic, deprecated, custom FindPythonLibs +* `-DPYBIND11_NOPYTHON=ON`: Disable all Python searching (disables tests) +* `-DBUILD_TESTING=ON`: Enable the tests +* `-DDOWNLOAD_CATCH=ON`: Download catch to build the C++ tests +* `-DDOWNLOAD_EIGEN=ON`: Download Eigen for the NumPy tests +* `-DPYBIND11_INSTALL=ON/OFF`: Enable the install target (on by default for the + master project) +* `-DUSE_PYTHON_INSTALL_DIR=ON`: Try to install into the python dir + + +
A few standard CMake tricks: (click to expand)

+ +* Use `cmake --build build -v` to see the commands used to build the files. +* Use `cmake build -LH` to list the CMake options with help. +* Use `ccmake` if available to see a curses (terminal) gui, or `cmake-gui` for + a completely graphical interface (not present in the PyPI package). +* Use `cmake --build build -j12` to build with 12 cores (for example). +* Use `-G` and the name of a generator to use something different. `cmake + --help` lists the generators available. + - On Unix, setting `CMAKE_GENERATER=Ninja` in your environment will give + you automatic mulithreading on all your CMake projects! +* Open the `CMakeLists.txt` with QtCreator to generate for that IDE. +* You can use `-DCMAKE_EXPORT_COMPILE_COMMANDS=ON` to generate the `.json` file + that some tools expect. + +

+ + +To run the tests, you can "build" the check target: + +```bash +cmake --build build --target check +``` + +`--target` can be spelled `-t` in CMake 3.15+. You can also run individual +tests with these targets: + +* `pytest`: Python tests only, using the +[pytest](https://docs.pytest.org/en/stable/) framework +* `cpptest`: C++ tests only +* `test_cmake_build`: Install / subdirectory tests + +If you want to build just a subset of tests, use +`-DPYBIND11_TEST_OVERRIDE="test_callbacks;test_pickling"`. If this is +empty, all tests will be built. Tests are specified without an extension if they need both a .py and +.cpp file. + +You may also pass flags to the `pytest` target by editing `tests/pytest.ini` or +by using the `PYTEST_ADDOPTS` environment variable +(see [`pytest` docs](https://docs.pytest.org/en/2.7.3/customize.html#adding-default-options)). As an example: + +```bash +env PYTEST_ADDOPTS="--capture=no --exitfirst" \ + cmake --build build --target pytest +# Or using abbreviated flags +env PYTEST_ADDOPTS="-s -x" cmake --build build --target pytest +``` + +### Formatting + +All formatting is handled by pre-commit. + +Install with brew (macOS) or pip (any OS): + +```bash +# Any OS +python3 -m pip install pre-commit + +# OR macOS with homebrew: +brew install pre-commit +``` + +Then, you can run it on the items you've added to your staging area, or all +files: + +```bash +pre-commit run +# OR +pre-commit run --all-files +``` + +And, if you want to always use it, you can install it as a git hook (hence the +name, pre-commit): + +```bash +pre-commit install +``` + +### Clang-Format + +As of v2.6.2, pybind11 ships with a [`clang-format`][clang-format] +configuration file at the top level of the repo (the filename is +`.clang-format`). Currently, formatting is NOT applied automatically, but +manually using `clang-format` for newly developed files is highly encouraged. +To check if a file needs formatting: + +```bash +clang-format -style=file --dry-run some.cpp +``` + +The output will show things to be fixed, if any. To actually format the file: + +```bash +clang-format -style=file -i some.cpp +``` + +Note that the `-style-file` option searches the parent directories for the +`.clang-format` file, i.e. the commands above can be run in any subdirectory +of the pybind11 repo. + +### Clang-Tidy + +[`clang-tidy`][clang-tidy] performs deeper static code analyses and is +more complex to run, compared to `clang-format`, but support for `clang-tidy` +is built into the pybind11 CMake configuration. To run `clang-tidy`, the +following recipe should work. Run the `docker` command from the top-level +directory inside your pybind11 git clone. Files will be modified in place, +so you can use git to monitor the changes. + +```bash +docker run --rm -v $PWD:/mounted_pybind11 -it silkeh/clang:15-bullseye +apt-get update && apt-get install -y git python3-dev python3-pytest +cmake -S /mounted_pybind11/ -B build -DCMAKE_CXX_CLANG_TIDY="$(which clang-tidy);--use-color" -DDOWNLOAD_EIGEN=ON -DDOWNLOAD_CATCH=ON -DCMAKE_CXX_STANDARD=17 +cmake --build build -j 2 +``` + +You can add `--fix` to the options list if you want. + +### Include what you use + +To run include what you use, install (`brew install include-what-you-use` on +macOS), then run: + +```bash +cmake -S . -B build-iwyu -DCMAKE_CXX_INCLUDE_WHAT_YOU_USE=$(which include-what-you-use) +cmake --build build +``` + +The report is sent to stderr; you can pipe it into a file if you wish. + +### Build recipes + +This builds with the Intel compiler (assuming it is in your path, along with a +recent CMake and Python): + +```bash +python3 -m venv venv +. venv/bin/activate +pip install pytest +cmake -S . -B build-intel -DCMAKE_CXX_COMPILER=$(which icpc) -DDOWNLOAD_CATCH=ON -DDOWNLOAD_EIGEN=ON -DPYBIND11_WERROR=ON +``` + +This will test the PGI compilers: + +```bash +docker run --rm -it -v $PWD:/pybind11 nvcr.io/hpc/pgi-compilers:ce +apt-get update && apt-get install -y python3-dev python3-pip python3-pytest +wget -qO- "https://cmake.org/files/v3.18/cmake-3.18.2-Linux-x86_64.tar.gz" | tar --strip-components=1 -xz -C /usr/local +cmake -S pybind11/ -B build +cmake --build build +``` + +### Explanation of the SDist/wheel building design + +> These details below are _only_ for packaging the Python sources from git. The +> SDists and wheels created do not have any extra requirements at all and are +> completely normal. + +The main objective of the packaging system is to create SDists (Python's source +distribution packages) and wheels (Python's binary distribution packages) that +include everything that is needed to work with pybind11, and which can be +installed without any additional dependencies. This is more complex than it +appears: in order to support CMake as a first class language even when using +the PyPI package, they must include the _generated_ CMake files (so as not to +require CMake when installing the `pybind11` package itself). They should also +provide the option to install to the "standard" location +(`/include/pybind11` and `/share/cmake/pybind11`) so they are +easy to find with CMake, but this can cause problems if you are not an +environment or using ``pyproject.toml`` requirements. This was solved by having +two packages; the "nice" pybind11 package that stores the includes and CMake +files inside the package, that you get access to via functions in the package, +and a `pybind11-global` package that can be included via `pybind11[global]` if +you want the more invasive but discoverable file locations. + +If you want to install or package the GitHub source, it is best to have Pip 10 +or newer on Windows, macOS, or Linux (manylinux1 compatible, includes most +distributions). You can then build the SDists, or run any procedure that makes +SDists internally, like making wheels or installing. + + +```bash +# Editable development install example +python3 -m pip install -e . +``` + +Since Pip itself does not have an `sdist` command (it does have `wheel` and +`install`), you may want to use the upcoming `build` package: + +```bash +python3 -m pip install build + +# Normal package +python3 -m build -s . + +# Global extra +PYBIND11_GLOBAL_SDIST=1 python3 -m build -s . +``` + +If you want to use the classic "direct" usage of `python setup.py`, you will +need CMake 3.15+ and either `make` or `ninja` preinstalled (possibly via `pip +install cmake ninja`), since directly running Python on `setup.py` cannot pick +up and install `pyproject.toml` requirements. As long as you have those two +things, though, everything works the way you would expect: + +```bash +# Normal package +python3 setup.py sdist + +# Global extra +PYBIND11_GLOBAL_SDIST=1 python3 setup.py sdist +``` + +A detailed explanation of the build procedure design for developers wanting to +work on or maintain the packaging system is as follows: + +#### 1. Building from the source directory + +When you invoke any `setup.py` command from the source directory, including +`pip wheel .` and `pip install .`, you will activate a full source build. This +is made of the following steps: + +1. If the tool is PEP 518 compliant, like Pip 10+, it will create a temporary + virtual environment and install the build requirements (mostly CMake) into + it. (if you are not on Windows, macOS, or a manylinux compliant system, you + can disable this with `--no-build-isolation` as long as you have CMake 3.15+ + installed) +2. The environment variable `PYBIND11_GLOBAL_SDIST` is checked - if it is set + and truthy, this will be make the accessory `pybind11-global` package, + instead of the normal `pybind11` package. This package is used for + installing the files directly to your environment root directory, using + `pybind11[global]`. +2. `setup.py` reads the version from `pybind11/_version.py` and verifies it + matches `includes/pybind11/detail/common.h`. +3. CMake is run with `-DCMAKE_INSTALL_PREIFX=pybind11`. Since the CMake install + procedure uses only relative paths and is identical on all platforms, these + files are valid as long as they stay in the correct relative position to the + includes. `pybind11/share/cmake/pybind11` has the CMake files, and + `pybind11/include` has the includes. The build directory is discarded. +4. Simpler files are placed in the SDist: `tools/setup_*.py.in`, + `tools/pyproject.toml` (`main` or `global`) +5. The package is created by running the setup function in the + `tools/setup_*.py`. `setup_main.py` fills in Python packages, and + `setup_global.py` fills in only the data/header slots. +6. A context manager cleans up the temporary CMake install directory (even if + an error is thrown). + +### 2. Building from SDist + +Since the SDist has the rendered template files in `tools` along with the +includes and CMake files in the correct locations, the builds are completely +trivial and simple. No extra requirements are required. You can even use Pip 9 +if you really want to. + + +[pre-commit]: https://pre-commit.com +[clang-format]: https://clang.llvm.org/docs/ClangFormat.html +[clang-tidy]: https://clang.llvm.org/extra/clang-tidy/ +[pybind11.readthedocs.org]: http://pybind11.readthedocs.org/en/latest +[issue tracker]: https://github.com/pybind/pybind11/issues +[gitter]: https://gitter.im/pybind/Lobby +[using pull requests]: https://help.github.com/articles/using-pull-requests diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/ISSUE_TEMPLATE/bug-report.yml b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/ISSUE_TEMPLATE/bug-report.yml new file mode 100644 index 000000000..4f1e78f33 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/ISSUE_TEMPLATE/bug-report.yml @@ -0,0 +1,61 @@ +name: Bug Report +description: File an issue about a bug +title: "[BUG]: " +labels: [triage] +body: + - type: markdown + attributes: + value: | + Please do your best to make the issue as easy to act on as possible, and only submit here if there is clearly a problem with pybind11 (ask first if unsure). **Note that a reproducer in a PR is much more likely to get immediate attention.** + + - type: checkboxes + id: steps + attributes: + label: Required prerequisites + description: Make sure you've completed the following steps before submitting your issue -- thank you! + options: + - label: Make sure you've read the [documentation](https://pybind11.readthedocs.io). Your issue may be addressed there. + required: true + - label: Search the [issue tracker](https://github.com/pybind/pybind11/issues) and [Discussions](https:/pybind/pybind11/discussions) to verify that this hasn't already been reported. +1 or comment there if it has. + required: true + - label: Consider asking first in the [Gitter chat room](https://gitter.im/pybind/Lobby) or in a [Discussion](https:/pybind/pybind11/discussions/new). + required: false + + - type: input + id: version + attributes: + label: What version (or hash if on master) of pybind11 are you using? + validations: + required: true + + - type: textarea + id: description + attributes: + label: Problem description + placeholder: >- + Provide a short description, state the expected behavior and what + actually happens. Include relevant information like what version of + pybind11 you are using, what system you are on, and any useful commands + / output. + validations: + required: true + + - type: textarea + id: code + attributes: + label: Reproducible example code + placeholder: >- + The code should be minimal, have no external dependencies, isolate the + function(s) that cause breakage. Submit matched and complete C++ and + Python snippets that can be easily compiled and run to diagnose the + issue. — Note that a reproducer in a PR is much more likely to get + immediate attention: failing tests in the pybind11 CI are the best + starting point for working out fixes. + render: text + + - type: input + id: regression + attributes: + label: Is this a regression? Put the last known working version here if it is. + description: Put the last known working version here if this is a regression. + value: Not a regression diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/ISSUE_TEMPLATE/config.yml b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/ISSUE_TEMPLATE/config.yml new file mode 100644 index 000000000..27f9a8044 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/ISSUE_TEMPLATE/config.yml @@ -0,0 +1,8 @@ +blank_issues_enabled: false +contact_links: + - name: Ask a question + url: https://github.com/pybind/pybind11/discussions/new + about: Please ask and answer questions here, or propose new ideas. + - name: Gitter room + url: https://gitter.im/pybind/Lobby + about: A room for discussing pybind11 with an active community diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/dependabot.yml b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/dependabot.yml new file mode 100644 index 000000000..2c7d17083 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/dependabot.yml @@ -0,0 +1,7 @@ +version: 2 +updates: + # Maintain dependencies for GitHub Actions + - package-ecosystem: "github-actions" + directory: "/" + schedule: + interval: "daily" diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/labeler.yml b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/labeler.yml new file mode 100644 index 000000000..abb0d05aa --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/labeler.yml @@ -0,0 +1,8 @@ +docs: +- any: + - 'docs/**/*.rst' + - '!docs/changelog.rst' + - '!docs/upgrade.rst' + +ci: +- '.github/workflows/*.yml' diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/labeler_merged.yml b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/labeler_merged.yml new file mode 100644 index 000000000..2374ad42e --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/labeler_merged.yml @@ -0,0 +1,3 @@ +needs changelog: +- all: + - '!docs/changelog.rst' diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/matchers/pylint.json b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/matchers/pylint.json new file mode 100644 index 000000000..e3a6bd16b --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/matchers/pylint.json @@ -0,0 +1,32 @@ +{ + "problemMatcher": [ + { + "severity": "warning", + "pattern": [ + { + "regexp": "^([^:]+):(\\d+):(\\d+): ([A-DF-Z]\\d+): \\033\\[[\\d;]+m([^\\033]+).*$", + "file": 1, + "line": 2, + "column": 3, + "code": 4, + "message": 5 + } + ], + "owner": "pylint-warning" + }, + { + "severity": "error", + "pattern": [ + { + "regexp": "^([^:]+):(\\d+):(\\d+): (E\\d+): \\033\\[[\\d;]+m([^\\033]+).*$", + "file": 1, + "line": 2, + "column": 3, + "code": 4, + "message": 5 + } + ], + "owner": "pylint-error" + } + ] +} diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/pull_request_template.md b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/pull_request_template.md new file mode 100644 index 000000000..54b7f5100 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/pull_request_template.md @@ -0,0 +1,19 @@ + +## Description + + + + +## Suggested changelog entry: + + + +```rst + +``` + + diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/ci.yml b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/ci.yml new file mode 100644 index 000000000..48f7c5e93 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/ci.yml @@ -0,0 +1,1165 @@ +name: CI + +on: + workflow_dispatch: + pull_request: + push: + branches: + - master + - stable + - v* + +permissions: read-all + +concurrency: + group: test-${{ github.ref }} + cancel-in-progress: true + +env: + PIP_BREAK_SYSTEM_PACKAGES: 1 + PIP_ONLY_BINARY: numpy + FORCE_COLOR: 3 + PYTEST_TIMEOUT: 300 + # For cmake: + VERBOSE: 1 + +jobs: + # This is the "main" test suite, which tests a large number of different + # versions of default compilers and Python versions in GitHub Actions. + standard: + strategy: + fail-fast: false + matrix: + runs-on: [ubuntu-20.04, windows-2022, macos-latest] + python: + - '3.6' + - '3.9' + - '3.10' + - '3.11' + - '3.12' + - 'pypy-3.8' + - 'pypy-3.9' + - 'pypy-3.10' + + # Items in here will either be added to the build matrix (if not + # present), or add new keys to an existing matrix element if all the + # existing keys match. + # + # We support an optional key: args, for cmake args + include: + # Just add a key + - runs-on: ubuntu-20.04 + python: '3.6' + args: > + -DPYBIND11_FINDPYTHON=ON + -DCMAKE_CXX_FLAGS="-D_=1" + - runs-on: ubuntu-20.04 + python: 'pypy-3.8' + args: > + -DPYBIND11_FINDPYTHON=ON + - runs-on: windows-2019 + python: '3.6' + args: > + -DPYBIND11_FINDPYTHON=ON + # Inject a couple Windows 2019 runs + - runs-on: windows-2019 + python: '3.9' + + name: "🐍 ${{ matrix.python }} • ${{ matrix.runs-on }} • x64 ${{ matrix.args }}" + runs-on: ${{ matrix.runs-on }} + + steps: + - uses: actions/checkout@v3 + + - name: Setup Python ${{ matrix.python }} + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python }} + allow-prereleases: true + + - name: Setup Boost (Linux) + # Can't use boost + define _ + if: runner.os == 'Linux' && matrix.python != '3.6' + run: sudo apt-get install libboost-dev + + - name: Setup Boost (macOS) + if: runner.os == 'macOS' + run: brew install boost + + - name: Update CMake + uses: jwlawson/actions-setup-cmake@v1.14 + + - name: Cache wheels + if: runner.os == 'macOS' + uses: actions/cache@v3 + with: + # This path is specific to macOS - we really only need it for PyPy NumPy wheels + # See https://github.com/actions/cache/blob/master/examples.md#python---pip + # for ways to do this more generally + path: ~/Library/Caches/pip + # Look to see if there is a cache hit for the corresponding requirements file + key: ${{ runner.os }}-pip-${{ matrix.python }}-x64-${{ hashFiles('tests/requirements.txt') }} + + - name: Prepare env + run: | + python -m pip install -r tests/requirements.txt + + - name: Setup annotations on Linux + if: runner.os == 'Linux' + run: python -m pip install pytest-github-actions-annotate-failures + + # First build - C++11 mode and inplace + # More-or-less randomly adding -DPYBIND11_SIMPLE_GIL_MANAGEMENT=ON here. + - name: Configure C++11 ${{ matrix.args }} + run: > + cmake -S . -B . + -DPYBIND11_WERROR=ON + -DPYBIND11_SIMPLE_GIL_MANAGEMENT=ON + -DDOWNLOAD_CATCH=ON + -DDOWNLOAD_EIGEN=ON + -DCMAKE_CXX_STANDARD=11 + ${{ matrix.args }} + + - name: Build C++11 + run: cmake --build . -j 2 + + - name: Python tests C++11 + run: cmake --build . --target pytest -j 2 + + - name: C++11 tests + # TODO: Figure out how to load the DLL on Python 3.8+ + if: "!(runner.os == 'Windows' && (matrix.python == 3.8 || matrix.python == 3.9 || matrix.python == '3.10' || matrix.python == '3.11' || matrix.python == 'pypy-3.8'))" + run: cmake --build . --target cpptest -j 2 + + - name: Interface test C++11 + run: cmake --build . --target test_cmake_build + + - name: Clean directory + run: git clean -fdx + + # Second build - C++17 mode and in a build directory + # More-or-less randomly adding -DPYBIND11_SIMPLE_GIL_MANAGEMENT=OFF here. + - name: Configure C++17 + run: > + cmake -S . -B build2 + -DPYBIND11_WERROR=ON + -DPYBIND11_SIMPLE_GIL_MANAGEMENT=OFF + -DDOWNLOAD_CATCH=ON + -DDOWNLOAD_EIGEN=ON + -DCMAKE_CXX_STANDARD=17 + ${{ matrix.args }} + + - name: Build + run: cmake --build build2 -j 2 + + - name: Python tests + run: cmake --build build2 --target pytest + + - name: C++ tests + # TODO: Figure out how to load the DLL on Python 3.8+ + if: "!(runner.os == 'Windows' && (matrix.python == 3.8 || matrix.python == 3.9 || matrix.python == '3.10' || matrix.python == '3.11' || matrix.python == 'pypy-3.8'))" + run: cmake --build build2 --target cpptest + + # Third build - C++17 mode with unstable ABI + - name: Configure (unstable ABI) + run: > + cmake -S . -B build3 + -DPYBIND11_WERROR=ON + -DDOWNLOAD_CATCH=ON + -DDOWNLOAD_EIGEN=ON + -DCMAKE_CXX_STANDARD=17 + -DPYBIND11_INTERNALS_VERSION=10000000 + ${{ matrix.args }} + + - name: Build (unstable ABI) + run: cmake --build build3 -j 2 + + - name: Python tests (unstable ABI) + run: cmake --build build3 --target pytest + + - name: Interface test + run: cmake --build build2 --target test_cmake_build + + # This makes sure the setup_helpers module can build packages using + # setuptools + - name: Setuptools helpers test + run: | + pip install setuptools + pytest tests/extra_setuptools + if: "!(matrix.runs-on == 'windows-2022')" + + + deadsnakes: + strategy: + fail-fast: false + matrix: + include: + # TODO: Fails on 3.10, investigate + - python-version: "3.9" + python-debug: true + valgrind: true + - python-version: "3.11" + python-debug: false + + name: "🐍 ${{ matrix.python-version }}${{ matrix.python-debug && '-dbg' || '' }} (deadsnakes)${{ matrix.valgrind && ' • Valgrind' || '' }} • x64" + runs-on: ubuntu-20.04 + + steps: + - uses: actions/checkout@v3 + + - name: Setup Python ${{ matrix.python-version }} (deadsnakes) + uses: deadsnakes/action@v3.0.1 + with: + python-version: ${{ matrix.python-version }} + debug: ${{ matrix.python-debug }} + + - name: Update CMake + uses: jwlawson/actions-setup-cmake@v1.14 + + - name: Valgrind cache + if: matrix.valgrind + uses: actions/cache@v3 + id: cache-valgrind + with: + path: valgrind + key: 3.16.1 # Valgrind version + + - name: Compile Valgrind + if: matrix.valgrind && steps.cache-valgrind.outputs.cache-hit != 'true' + run: | + VALGRIND_VERSION=3.16.1 + curl https://sourceware.org/pub/valgrind/valgrind-$VALGRIND_VERSION.tar.bz2 -o - | tar xj + mv valgrind-$VALGRIND_VERSION valgrind + cd valgrind + ./configure + make -j 2 > /dev/null + + - name: Install Valgrind + if: matrix.valgrind + working-directory: valgrind + run: | + sudo make install + sudo apt-get update + sudo apt-get install libc6-dbg # Needed by Valgrind + + - name: Prepare env + run: | + python -m pip install -r tests/requirements.txt + + - name: Configure + run: > + cmake -S . -B build + -DCMAKE_BUILD_TYPE=Debug + -DPYBIND11_WERROR=ON + -DDOWNLOAD_CATCH=ON + -DDOWNLOAD_EIGEN=ON + -DCMAKE_CXX_STANDARD=17 + + - name: Build + run: cmake --build build -j 2 + + - name: Python tests + run: cmake --build build --target pytest + + - name: C++ tests + run: cmake --build build --target cpptest + + - name: Run Valgrind on Python tests + if: matrix.valgrind + run: cmake --build build --target memcheck + + + # Testing on clang using the excellent silkeh clang docker images + clang: + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + clang: + - 3.6 + - 3.7 + - 3.9 + - 7 + - 9 + - dev + std: + - 11 + container_suffix: + - "" + include: + - clang: 5 + std: 14 + - clang: 10 + std: 17 + - clang: 11 + std: 20 + - clang: 12 + std: 20 + - clang: 13 + std: 20 + - clang: 14 + std: 20 + - clang: 15 + std: 20 + container_suffix: "-bullseye" + + name: "🐍 3 • Clang ${{ matrix.clang }} • C++${{ matrix.std }} • x64" + container: "silkeh/clang:${{ matrix.clang }}${{ matrix.container_suffix }}" + + steps: + - uses: actions/checkout@v3 + + - name: Add wget and python3 + run: apt-get update && apt-get install -y python3-dev python3-numpy python3-pytest libeigen3-dev + + - name: Configure + shell: bash + run: > + cmake -S . -B build + -DPYBIND11_WERROR=ON + -DDOWNLOAD_CATCH=ON + -DCMAKE_CXX_STANDARD=${{ matrix.std }} + -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)") + + - name: Build + run: cmake --build build -j 2 + + - name: Python tests + run: cmake --build build --target pytest + + - name: C++ tests + run: cmake --build build --target cpptest + + - name: Interface test + run: cmake --build build --target test_cmake_build + + + # Testing NVCC; forces sources to behave like .cu files + cuda: + runs-on: ubuntu-latest + name: "🐍 3.10 • CUDA 12.2 • Ubuntu 22.04" + container: nvidia/cuda:12.2.0-devel-ubuntu22.04 + + steps: + - uses: actions/checkout@v3 + + # tzdata will try to ask for the timezone, so set the DEBIAN_FRONTEND + - name: Install 🐍 3 + run: apt-get update && DEBIAN_FRONTEND="noninteractive" apt-get install -y cmake git python3-dev python3-pytest python3-numpy + + - name: Configure + run: cmake -S . -B build -DPYBIND11_CUDA_TESTS=ON -DPYBIND11_WERROR=ON -DDOWNLOAD_CATCH=ON + + - name: Build + run: cmake --build build -j2 --verbose + + - name: Python tests + run: cmake --build build --target pytest + + +# TODO: Internal compiler error - report to NVidia +# # Testing CentOS 8 + PGI compilers +# centos-nvhpc8: +# runs-on: ubuntu-latest +# name: "🐍 3 • CentOS8 / PGI 20.11 • x64" +# container: centos:8 +# +# steps: +# - uses: actions/checkout@v3 +# +# - name: Add Python 3 and a few requirements +# run: yum update -y && yum install -y git python3-devel python3-numpy python3-pytest make environment-modules +# +# - name: Install CMake with pip +# run: | +# python3 -m pip install --upgrade pip +# python3 -m pip install cmake --prefer-binary +# +# - name: Install NVidia HPC SDK +# run: > +# yum -y install +# https://developer.download.nvidia.com/hpc-sdk/20.11/nvhpc-20-11-20.11-1.x86_64.rpm +# https://developer.download.nvidia.com/hpc-sdk/20.11/nvhpc-2020-20.11-1.x86_64.rpm +# +# - name: Configure +# shell: bash +# run: | +# source /etc/profile.d/modules.sh +# module load /opt/nvidia/hpc_sdk/modulefiles/nvhpc/20.11 +# cmake -S . -B build -DDOWNLOAD_CATCH=ON -DCMAKE_CXX_STANDARD=14 -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)") +# +# - name: Build +# run: cmake --build build -j 2 --verbose +# +# - name: Python tests +# run: cmake --build build --target pytest +# +# - name: C++ tests +# run: cmake --build build --target cpptest +# +# - name: Interface test +# run: cmake --build build --target test_cmake_build + + + # Testing on CentOS 7 + PGI compilers, which seems to require more workarounds + centos-nvhpc7: + if: ${{ false }} # JOB DISABLED (NEEDS WORK): https://github.com/pybind/pybind11/issues/4690 + runs-on: ubuntu-latest + name: "🐍 3 • CentOS7 / PGI 22.9 • x64" + container: centos:7 + + steps: + - uses: actions/checkout@v3 + + - name: Add Python 3 and a few requirements + run: yum update -y && yum install -y epel-release && yum install -y git python3-devel make environment-modules cmake3 yum-utils + + - name: Install NVidia HPC SDK + run: yum-config-manager --add-repo https://developer.download.nvidia.com/hpc-sdk/rhel/nvhpc.repo && yum -y install nvhpc-22.9 + + # On CentOS 7, we have to filter a few tests (compiler internal error) + # and allow deeper template recursion (not needed on CentOS 8 with a newer + # standard library). On some systems, you many need further workarounds: + # https://github.com/pybind/pybind11/pull/2475 + - name: Configure + shell: bash + run: | + source /etc/profile.d/modules.sh + module load /opt/nvidia/hpc_sdk/modulefiles/nvhpc/22.9 + cmake3 -S . -B build -DDOWNLOAD_CATCH=ON \ + -DCMAKE_CXX_STANDARD=11 \ + -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)") \ + -DCMAKE_CXX_FLAGS="-Wc,--pending_instantiations=0" \ + -DPYBIND11_TEST_FILTER="test_smart_ptr.cpp" + + # Building before installing Pip should produce a warning but not an error + - name: Build + run: cmake3 --build build -j 2 --verbose + + - name: Install CMake with pip + run: | + python3 -m pip install --upgrade pip + python3 -m pip install pytest + + - name: Python tests + run: cmake3 --build build --target pytest + + - name: C++ tests + run: cmake3 --build build --target cpptest + + - name: Interface test + run: cmake3 --build build --target test_cmake_build + + + # Testing on GCC using the GCC docker images (only recent images supported) + gcc: + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + include: + - { gcc: 7, std: 11 } + - { gcc: 7, std: 17 } + - { gcc: 8, std: 14 } + - { gcc: 8, std: 17 } + - { gcc: 10, std: 17 } + - { gcc: 11, std: 20 } + - { gcc: 12, std: 20 } + + name: "🐍 3 • GCC ${{ matrix.gcc }} • C++${{ matrix.std }}• x64" + container: "gcc:${{ matrix.gcc }}" + + steps: + - uses: actions/checkout@v3 + + - name: Add Python 3 + run: apt-get update; apt-get install -y python3-dev python3-numpy python3-pytest python3-pip libeigen3-dev + + - name: Update pip + run: python3 -m pip install --upgrade pip + + - name: Update CMake + uses: jwlawson/actions-setup-cmake@v1.14 + + - name: Configure + shell: bash + run: > + cmake -S . -B build + -DPYBIND11_WERROR=ON + -DDOWNLOAD_CATCH=ON + -DCMAKE_CXX_STANDARD=${{ matrix.std }} + -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)") + + - name: Build + run: cmake --build build -j 2 + + - name: Python tests + run: cmake --build build --target pytest + + - name: C++ tests + run: cmake --build build --target cpptest + + - name: Interface test + run: cmake --build build --target test_cmake_build + + - name: Configure - Exercise cmake -DPYBIND11_TEST_OVERRIDE + if: matrix.gcc == '12' + shell: bash + run: > + cmake -S . -B build_partial + -DPYBIND11_WERROR=ON + -DDOWNLOAD_CATCH=ON + -DCMAKE_CXX_STANDARD=${{ matrix.std }} + -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)") + "-DPYBIND11_TEST_OVERRIDE=test_call_policies.cpp;test_gil_scoped.cpp;test_thread.cpp" + + - name: Build - Exercise cmake -DPYBIND11_TEST_OVERRIDE + if: matrix.gcc == '12' + run: cmake --build build_partial -j 2 + + - name: Python tests - Exercise cmake -DPYBIND11_TEST_OVERRIDE + if: matrix.gcc == '12' + run: cmake --build build_partial --target pytest + + # Testing on ICC using the oneAPI apt repo + icc: + runs-on: ubuntu-20.04 + strategy: + fail-fast: false + + name: "🐍 3 • ICC latest • x64" + + steps: + - uses: actions/checkout@v3 + + - name: Add apt repo + run: | + sudo apt-get update + sudo apt-get install -y wget build-essential pkg-config cmake ca-certificates gnupg + wget https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS-2023.PUB + sudo apt-key add GPG-PUB-KEY-INTEL-SW-PRODUCTS-2023.PUB + echo "deb https://apt.repos.intel.com/oneapi all main" | sudo tee /etc/apt/sources.list.d/oneAPI.list + + - name: Add ICC & Python 3 + run: sudo apt-get update; sudo apt-get install -y intel-oneapi-compiler-dpcpp-cpp-and-cpp-classic cmake python3-dev python3-numpy python3-pytest python3-pip + + - name: Update pip + run: | + set +e; source /opt/intel/oneapi/setvars.sh; set -e + python3 -m pip install --upgrade pip + + - name: Install dependencies + run: | + set +e; source /opt/intel/oneapi/setvars.sh; set -e + python3 -m pip install -r tests/requirements.txt + + - name: Configure C++11 + run: | + set +e; source /opt/intel/oneapi/setvars.sh; set -e + cmake -S . -B build-11 \ + -DPYBIND11_WERROR=ON \ + -DDOWNLOAD_CATCH=ON \ + -DDOWNLOAD_EIGEN=OFF \ + -DCMAKE_CXX_STANDARD=11 \ + -DCMAKE_CXX_COMPILER=$(which icpc) \ + -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)") + + - name: Build C++11 + run: | + set +e; source /opt/intel/oneapi/setvars.sh; set -e + cmake --build build-11 -j 2 -v + + - name: Python tests C++11 + run: | + set +e; source /opt/intel/oneapi/setvars.sh; set -e + sudo service apport stop + cmake --build build-11 --target check + + - name: C++ tests C++11 + run: | + set +e; source /opt/intel/oneapi/setvars.sh; set -e + cmake --build build-11 --target cpptest + + - name: Interface test C++11 + run: | + set +e; source /opt/intel/oneapi/setvars.sh; set -e + cmake --build build-11 --target test_cmake_build + + - name: Configure C++17 + run: | + set +e; source /opt/intel/oneapi/setvars.sh; set -e + cmake -S . -B build-17 \ + -DPYBIND11_WERROR=ON \ + -DDOWNLOAD_CATCH=ON \ + -DDOWNLOAD_EIGEN=OFF \ + -DCMAKE_CXX_STANDARD=17 \ + -DCMAKE_CXX_COMPILER=$(which icpc) \ + -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)") + + - name: Build C++17 + run: | + set +e; source /opt/intel/oneapi/setvars.sh; set -e + cmake --build build-17 -j 2 -v + + - name: Python tests C++17 + run: | + set +e; source /opt/intel/oneapi/setvars.sh; set -e + sudo service apport stop + cmake --build build-17 --target check + + - name: C++ tests C++17 + run: | + set +e; source /opt/intel/oneapi/setvars.sh; set -e + cmake --build build-17 --target cpptest + + - name: Interface test C++17 + run: | + set +e; source /opt/intel/oneapi/setvars.sh; set -e + cmake --build build-17 --target test_cmake_build + + + # Testing on CentOS (manylinux uses a centos base, and this is an easy way + # to get GCC 4.8, which is the manylinux1 compiler). + centos: + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + container: + - "centos:7" # GCC 4.8 + - "almalinux:8" + - "almalinux:9" + + name: "🐍 3 • ${{ matrix.container }} • x64" + container: "${{ matrix.container }}" + + steps: + - uses: actions/checkout@v3 + + - name: Add Python 3 (RHEL 7) + if: matrix.container == 'centos:7' + run: yum update -y && yum install -y python3-devel gcc-c++ make git + + - name: Add Python 3 (RHEL 8+) + if: matrix.container != 'centos:7' + run: dnf update -y && dnf install -y python3-devel gcc-c++ make git + + - name: Update pip + run: python3 -m pip install --upgrade pip + + - name: Install dependencies + run: | + python3 -m pip install cmake -r tests/requirements.txt + + - name: Configure + shell: bash + run: > + cmake -S . -B build + -DCMAKE_BUILD_TYPE=MinSizeRel + -DPYBIND11_WERROR=ON + -DDOWNLOAD_CATCH=ON + -DDOWNLOAD_EIGEN=ON + -DCMAKE_CXX_STANDARD=11 + -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)") + + - name: Build + run: cmake --build build -j 2 + + - name: Python tests + run: cmake --build build --target pytest + + - name: C++ tests + run: cmake --build build --target cpptest + + - name: Interface test + run: cmake --build build --target test_cmake_build + + + # This tests an "install" with the CMake tools + install-classic: + name: "🐍 3.7 • Debian • x86 • Install" + runs-on: ubuntu-latest + container: i386/debian:buster + + steps: + - uses: actions/checkout@v1 # Required to run inside docker + + - name: Install requirements + run: | + apt-get update + apt-get install -y git make cmake g++ libeigen3-dev python3-dev python3-pip + pip3 install "pytest==6.*" + + - name: Configure for install + run: > + cmake . + -DPYBIND11_INSTALL=1 -DPYBIND11_TEST=0 + -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)") + + - name: Make and install + run: make install + + - name: Copy tests to new directory + run: cp -a tests /pybind11-tests + + - name: Make a new test directory + run: mkdir /build-tests + + - name: Configure tests + run: > + cmake ../pybind11-tests + -DDOWNLOAD_CATCH=ON + -DPYBIND11_WERROR=ON + -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)") + working-directory: /build-tests + + - name: Python tests + run: make pytest -j 2 + working-directory: /build-tests + + + # This verifies that the documentation is not horribly broken, and does a + # basic validation check on the SDist. + doxygen: + name: "Documentation build test" + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v3 + + - uses: actions/setup-python@v4 + with: + python-version: "3.x" + + - name: Install Doxygen + run: sudo apt-get install -y doxygen librsvg2-bin # Changed to rsvg-convert in 20.04 + + - name: Build docs + run: pipx run nox -s docs + + - name: Make SDist + run: pipx run nox -s build -- --sdist + + - run: git status --ignored + + - name: Check local include dir + run: > + ls pybind11; + python3 -c "import pybind11, pathlib; assert (a := pybind11.get_include()) == (b := str(pathlib.Path('include').resolve())), f'{a} != {b}'" + + - name: Compare Dists (headers only) + working-directory: include + run: | + python3 -m pip install --user -U ../dist/*.tar.gz + installed=$(python3 -c "import pybind11; print(pybind11.get_include() + '/pybind11')") + diff -rq $installed ./pybind11 + + win32: + strategy: + fail-fast: false + matrix: + python: + - 3.6 + - 3.7 + - 3.8 + - 3.9 + + include: + - python: 3.9 + args: -DCMAKE_CXX_STANDARD=20 + - python: 3.8 + args: -DCMAKE_CXX_STANDARD=17 + - python: 3.7 + args: -DCMAKE_CXX_STANDARD=14 + + + name: "🐍 ${{ matrix.python }} • MSVC 2019 • x86 ${{ matrix.args }}" + runs-on: windows-2019 + + steps: + - uses: actions/checkout@v3 + + - name: Setup Python ${{ matrix.python }} + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python }} + architecture: x86 + + - name: Update CMake + uses: jwlawson/actions-setup-cmake@v1.14 + + - name: Prepare MSVC + uses: ilammy/msvc-dev-cmd@v1.12.1 + with: + arch: x86 + + - name: Prepare env + run: | + python -m pip install -r tests/requirements.txt + + # First build - C++11 mode and inplace + - name: Configure ${{ matrix.args }} + run: > + cmake -S . -B build + -G "Visual Studio 16 2019" -A Win32 + -DPYBIND11_WERROR=ON + -DDOWNLOAD_CATCH=ON + -DDOWNLOAD_EIGEN=ON + ${{ matrix.args }} + - name: Build C++11 + run: cmake --build build -j 2 + + - name: Python tests + run: cmake --build build -t pytest + + win32-debug: + strategy: + fail-fast: false + matrix: + python: + - 3.8 + - 3.9 + + include: + - python: 3.9 + args: -DCMAKE_CXX_STANDARD=20 + - python: 3.8 + args: -DCMAKE_CXX_STANDARD=17 + + name: "🐍 ${{ matrix.python }} • MSVC 2019 (Debug) • x86 ${{ matrix.args }}" + runs-on: windows-2019 + + steps: + - uses: actions/checkout@v3 + + - name: Setup Python ${{ matrix.python }} + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python }} + architecture: x86 + + - name: Update CMake + uses: jwlawson/actions-setup-cmake@v1.14 + + - name: Prepare MSVC + uses: ilammy/msvc-dev-cmd@v1.12.1 + with: + arch: x86 + + - name: Prepare env + run: | + python -m pip install -r tests/requirements.txt + + # First build - C++11 mode and inplace + - name: Configure ${{ matrix.args }} + run: > + cmake -S . -B build + -G "Visual Studio 16 2019" -A Win32 + -DCMAKE_BUILD_TYPE=Debug + -DPYBIND11_WERROR=ON + -DDOWNLOAD_CATCH=ON + -DDOWNLOAD_EIGEN=ON + ${{ matrix.args }} + - name: Build C++11 + run: cmake --build build --config Debug -j 2 + + - name: Python tests + run: cmake --build build --config Debug -t pytest + + + windows-2022: + strategy: + fail-fast: false + matrix: + python: + - 3.9 + + name: "🐍 ${{ matrix.python }} • MSVC 2022 C++20 • x64" + runs-on: windows-2022 + + steps: + - uses: actions/checkout@v3 + + - name: Setup Python ${{ matrix.python }} + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python }} + + - name: Prepare env + run: | + python3 -m pip install -r tests/requirements.txt + + - name: Update CMake + uses: jwlawson/actions-setup-cmake@v1.14 + + - name: Configure C++20 + run: > + cmake -S . -B build + -DPYBIND11_WERROR=ON + -DDOWNLOAD_CATCH=ON + -DDOWNLOAD_EIGEN=ON + -DCMAKE_CXX_STANDARD=20 + + - name: Build C++20 + run: cmake --build build -j 2 + + - name: Python tests + run: cmake --build build --target pytest + + - name: C++20 tests + run: cmake --build build --target cpptest -j 2 + + - name: Interface test C++20 + run: cmake --build build --target test_cmake_build + + - name: Configure C++20 - Exercise cmake -DPYBIND11_TEST_OVERRIDE + run: > + cmake -S . -B build_partial + -DPYBIND11_WERROR=ON + -DDOWNLOAD_CATCH=ON + -DDOWNLOAD_EIGEN=ON + -DCMAKE_CXX_STANDARD=20 + "-DPYBIND11_TEST_OVERRIDE=test_call_policies.cpp;test_gil_scoped.cpp;test_thread.cpp" + + - name: Build C++20 - Exercise cmake -DPYBIND11_TEST_OVERRIDE + run: cmake --build build_partial -j 2 + + - name: Python tests - Exercise cmake -DPYBIND11_TEST_OVERRIDE + run: cmake --build build_partial --target pytest + + mingw: + name: "🐍 3 • windows-latest • ${{ matrix.sys }}" + runs-on: windows-latest + defaults: + run: + shell: msys2 {0} + strategy: + fail-fast: false + matrix: + include: + - { sys: mingw64, env: x86_64 } + - { sys: mingw32, env: i686 } + steps: + - uses: msys2/setup-msys2@v2 + with: + msystem: ${{matrix.sys}} + install: >- + git + mingw-w64-${{matrix.env}}-gcc + mingw-w64-${{matrix.env}}-python-pip + mingw-w64-${{matrix.env}}-python-numpy + mingw-w64-${{matrix.env}}-python-scipy + mingw-w64-${{matrix.env}}-cmake + mingw-w64-${{matrix.env}}-make + mingw-w64-${{matrix.env}}-python-pytest + mingw-w64-${{matrix.env}}-eigen3 + mingw-w64-${{matrix.env}}-boost + mingw-w64-${{matrix.env}}-catch + + - uses: actions/checkout@v3 + + - name: Configure C++11 + # LTO leads to many undefined reference like + # `pybind11::detail::function_call::function_call(pybind11::detail::function_call&&) + run: cmake -G "MinGW Makefiles" -DCMAKE_CXX_STANDARD=11 -DPYBIND11_WERROR=ON -DDOWNLOAD_CATCH=ON -S . -B build + + - name: Build C++11 + run: cmake --build build -j 2 + + - name: Python tests C++11 + run: cmake --build build --target pytest -j 2 + + - name: C++11 tests + run: PYTHONHOME=/${{matrix.sys}} PYTHONPATH=/${{matrix.sys}} cmake --build build --target cpptest -j 2 + + - name: Interface test C++11 + run: PYTHONHOME=/${{matrix.sys}} PYTHONPATH=/${{matrix.sys}} cmake --build build --target test_cmake_build + + - name: Clean directory + run: git clean -fdx + + - name: Configure C++14 + run: cmake -G "MinGW Makefiles" -DCMAKE_CXX_STANDARD=14 -DPYBIND11_WERROR=ON -DDOWNLOAD_CATCH=ON -S . -B build2 + + - name: Build C++14 + run: cmake --build build2 -j 2 + + - name: Python tests C++14 + run: cmake --build build2 --target pytest -j 2 + + - name: C++14 tests + run: PYTHONHOME=/${{matrix.sys}} PYTHONPATH=/${{matrix.sys}} cmake --build build2 --target cpptest -j 2 + + - name: Interface test C++14 + run: PYTHONHOME=/${{matrix.sys}} PYTHONPATH=/${{matrix.sys}} cmake --build build2 --target test_cmake_build + + - name: Clean directory + run: git clean -fdx + + - name: Configure C++17 + run: cmake -G "MinGW Makefiles" -DCMAKE_CXX_STANDARD=17 -DPYBIND11_WERROR=ON -DDOWNLOAD_CATCH=ON -S . -B build3 + + - name: Build C++17 + run: cmake --build build3 -j 2 + + - name: Python tests C++17 + run: cmake --build build3 --target pytest -j 2 + + - name: C++17 tests + run: PYTHONHOME=/${{matrix.sys}} PYTHONPATH=/${{matrix.sys}} cmake --build build3 --target cpptest -j 2 + + - name: Interface test C++17 + run: PYTHONHOME=/${{matrix.sys}} PYTHONPATH=/${{matrix.sys}} cmake --build build3 --target test_cmake_build + + windows_clang: + + strategy: + matrix: + os: [windows-latest] + python: ['3.10'] + + runs-on: "${{ matrix.os }}" + + name: "🐍 ${{ matrix.python }} • ${{ matrix.os }} • clang-latest" + + steps: + - name: Show env + run: env + + - name: Checkout + uses: actions/checkout@v3 + + - name: Set up Clang + uses: egor-tensin/setup-clang@v1 + + - name: Setup Python ${{ matrix.python }} + uses: actions/setup-python@v4 + with: + python-version: ${{ matrix.python }} + + - name: Update CMake + uses: jwlawson/actions-setup-cmake@v1.14 + + - name: Install ninja-build tool + uses: seanmiddleditch/gha-setup-ninja@v3 + + - name: Run pip installs + run: | + python -m pip install --upgrade pip + python -m pip install -r tests/requirements.txt + + - name: Show Clang++ version + run: clang++ --version + + - name: Show CMake version + run: cmake --version + + # TODO: WERROR=ON + - name: Configure Clang + run: > + cmake -G Ninja -S . -B . + -DPYBIND11_WERROR=OFF + -DPYBIND11_SIMPLE_GIL_MANAGEMENT=OFF + -DDOWNLOAD_CATCH=ON + -DDOWNLOAD_EIGEN=ON + -DCMAKE_CXX_COMPILER=clang++ + -DCMAKE_CXX_STANDARD=17 + + - name: Build + run: cmake --build . -j 2 + + - name: Python tests + run: cmake --build . --target pytest -j 2 + + - name: C++ tests + run: cmake --build . --target cpptest -j 2 + + - name: Interface test + run: cmake --build . --target test_cmake_build -j 2 + + - name: Clean directory + run: git clean -fdx + + macos_brew_install_llvm: + name: "macos-latest • brew install llvm" + runs-on: macos-latest + + env: + # https://apple.stackexchange.com/questions/227026/how-to-install-recent-clang-with-homebrew + LDFLAGS: '-L/usr/local/opt/llvm/lib -Wl,-rpath,/usr/local/opt/llvm/lib' + + steps: + - name: Update PATH + run: echo "/usr/local/opt/llvm/bin" >> $GITHUB_PATH + + - name: Show env + run: env + + - name: Checkout + uses: actions/checkout@v3 + + - name: Show Clang++ version before brew install llvm + run: clang++ --version + + - name: brew install llvm + run: brew install llvm + + - name: Show Clang++ version after brew install llvm + run: clang++ --version + + - name: Update CMake + uses: jwlawson/actions-setup-cmake@v1.14 + + - name: Run pip installs + run: | + python3 -m pip install --upgrade pip + python3 -m pip install -r tests/requirements.txt + python3 -m pip install numpy + python3 -m pip install scipy + + - name: Show CMake version + run: cmake --version + + - name: CMake Configure + run: > + cmake -S . -B . + -DPYBIND11_WERROR=ON + -DPYBIND11_SIMPLE_GIL_MANAGEMENT=OFF + -DDOWNLOAD_CATCH=ON + -DDOWNLOAD_EIGEN=ON + -DCMAKE_CXX_COMPILER=clang++ + -DCMAKE_CXX_STANDARD=17 + -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)") + + - name: Build + run: cmake --build . -j 2 + + - name: Python tests + run: cmake --build . --target pytest -j 2 + + - name: C++ tests + run: cmake --build . --target cpptest -j 2 + + - name: Interface test + run: cmake --build . --target test_cmake_build -j 2 + + - name: CMake Configure - Exercise cmake -DPYBIND11_TEST_OVERRIDE + run: > + cmake -S . -B build_partial + -DPYBIND11_WERROR=ON + -DPYBIND11_SIMPLE_GIL_MANAGEMENT=OFF + -DDOWNLOAD_CATCH=ON + -DDOWNLOAD_EIGEN=ON + -DCMAKE_CXX_COMPILER=clang++ + -DCMAKE_CXX_STANDARD=17 + -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)") + "-DPYBIND11_TEST_OVERRIDE=test_call_policies.cpp;test_gil_scoped.cpp;test_thread.cpp" + + - name: Build - Exercise cmake -DPYBIND11_TEST_OVERRIDE + run: cmake --build build_partial -j 2 + + - name: Python tests - Exercise cmake -DPYBIND11_TEST_OVERRIDE + run: cmake --build build_partial --target pytest -j 2 + + - name: Clean directory + run: git clean -fdx diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/configure.yml b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/configure.yml new file mode 100644 index 000000000..ec7cd612d --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/configure.yml @@ -0,0 +1,92 @@ +name: Config + +on: + workflow_dispatch: + pull_request: + push: + branches: + - master + - stable + - v* + +permissions: + contents: read + +env: + PIP_BREAK_SYSTEM_PACKAGES: 1 + # For cmake: + VERBOSE: 1 + +jobs: + # This tests various versions of CMake in various combinations, to make sure + # the configure step passes. + cmake: + strategy: + fail-fast: false + matrix: + runs-on: [ubuntu-20.04, macos-latest, windows-latest] + arch: [x64] + cmake: ["3.26"] + + include: + - runs-on: ubuntu-20.04 + arch: x64 + cmake: "3.5" + + - runs-on: ubuntu-20.04 + arch: x64 + cmake: "3.27" + + - runs-on: macos-latest + arch: x64 + cmake: "3.7" + + - runs-on: windows-2019 + arch: x64 # x86 compilers seem to be missing on 2019 image + cmake: "3.18" + + name: 🐍 3.7 • CMake ${{ matrix.cmake }} • ${{ matrix.runs-on }} + runs-on: ${{ matrix.runs-on }} + + steps: + - uses: actions/checkout@v3 + + - name: Setup Python 3.7 + uses: actions/setup-python@v4 + with: + python-version: 3.7 + architecture: ${{ matrix.arch }} + + - name: Prepare env + run: python -m pip install -r tests/requirements.txt + + # An action for adding a specific version of CMake: + # https://github.com/jwlawson/actions-setup-cmake + - name: Setup CMake ${{ matrix.cmake }} + uses: jwlawson/actions-setup-cmake@v1.14 + with: + cmake-version: ${{ matrix.cmake }} + + # These steps use a directory with a space in it intentionally + - name: Make build directories + run: mkdir "build dir" + + - name: Configure + working-directory: build dir + shell: bash + run: > + cmake .. + -DPYBIND11_WERROR=ON + -DDOWNLOAD_CATCH=ON + -DPYTHON_EXECUTABLE=$(python -c "import sys; print(sys.executable)") + + # Only build and test if this was manually triggered in the GitHub UI + - name: Build + working-directory: build dir + if: github.event_name == 'workflow_dispatch' + run: cmake --build . --config Release + + - name: Test + working-directory: build dir + if: github.event_name == 'workflow_dispatch' + run: cmake --build . --config Release --target check diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/format.yml b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/format.yml new file mode 100644 index 000000000..b8242ee52 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/format.yml @@ -0,0 +1,60 @@ +# This is a format job. Pre-commit has a first-party GitHub action, so we use +# that: https://github.com/pre-commit/action + +name: Format + +on: + workflow_dispatch: + pull_request: + push: + branches: + - master + - stable + - "v*" + +permissions: + contents: read + +env: + FORCE_COLOR: 3 + # For cmake: + VERBOSE: 1 + +jobs: + pre-commit: + name: Format + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - uses: actions/setup-python@v4 + with: + python-version: "3.x" + - name: Add matchers + run: echo "::add-matcher::$GITHUB_WORKSPACE/.github/matchers/pylint.json" + - uses: pre-commit/action@v3.0.0 + with: + # Slow hooks are marked with manual - slow is okay here, run them too + extra_args: --hook-stage manual --all-files + + clang-tidy: + # When making changes here, please also review the "Clang-Tidy" section + # in .github/CONTRIBUTING.md and update as needed. + name: Clang-Tidy + runs-on: ubuntu-latest + container: silkeh/clang:15-bullseye + steps: + - uses: actions/checkout@v3 + + - name: Install requirements + run: apt-get update && apt-get install -y git python3-dev python3-pytest + + - name: Configure + run: > + cmake -S . -B build + -DCMAKE_CXX_CLANG_TIDY="$(which clang-tidy);--use-color;--warnings-as-errors=*" + -DDOWNLOAD_EIGEN=ON + -DDOWNLOAD_CATCH=ON + -DCMAKE_CXX_STANDARD=17 + + - name: Build + run: cmake --build build -j 2 -- --keep-going diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/labeler.yml b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/labeler.yml new file mode 100644 index 000000000..858a4a0e2 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/labeler.yml @@ -0,0 +1,25 @@ +name: Labeler +on: + pull_request_target: + types: [closed] + +permissions: {} + +jobs: + label: + name: Labeler + runs-on: ubuntu-latest + permissions: + contents: read + pull-requests: write + steps: + + - uses: actions/labeler@main + if: > + github.event.pull_request.merged == true && + !startsWith(github.event.pull_request.title, 'chore(deps):') && + !startsWith(github.event.pull_request.title, 'ci(fix):') && + !startsWith(github.event.pull_request.title, 'docs(changelog):') + with: + repo-token: ${{ secrets.GITHUB_TOKEN }} + configuration-path: .github/labeler_merged.yml diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/pip.yml b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/pip.yml new file mode 100644 index 000000000..d6687b441 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/pip.yml @@ -0,0 +1,114 @@ +name: Pip + +on: + workflow_dispatch: + pull_request: + push: + branches: + - master + - stable + - v* + release: + types: + - published + +permissions: + contents: read + +env: + PIP_BREAK_SYSTEM_PACKAGES: 1 + PIP_ONLY_BINARY: numpy + +jobs: + # This builds the sdists and wheels and makes sure the files are exactly as + # expected. Using Windows and Python 3.6, since that is often the most + # challenging matrix element. + test-packaging: + name: 🐍 3.6 • 📦 tests • windows-latest + runs-on: windows-latest + + steps: + - uses: actions/checkout@v3 + + - name: Setup 🐍 3.6 + uses: actions/setup-python@v4 + with: + python-version: 3.6 + + - name: Prepare env + run: | + python -m pip install -r tests/requirements.txt + + - name: Python Packaging tests + run: pytest tests/extra_python_package/ + + + # This runs the packaging tests and also builds and saves the packages as + # artifacts. + packaging: + name: 🐍 3.8 • 📦 & 📦 tests • ubuntu-latest + runs-on: ubuntu-latest + + steps: + - uses: actions/checkout@v3 + + - name: Setup 🐍 3.8 + uses: actions/setup-python@v4 + with: + python-version: 3.8 + + - name: Prepare env + run: | + python -m pip install -r tests/requirements.txt build twine + + - name: Python Packaging tests + run: pytest tests/extra_python_package/ + + - name: Build SDist and wheels + run: | + python -m build + PYBIND11_GLOBAL_SDIST=1 python -m build + + - name: Check metadata + run: twine check dist/* + + - name: Save standard package + uses: actions/upload-artifact@v3 + with: + name: standard + path: dist/pybind11-* + + - name: Save global package + uses: actions/upload-artifact@v3 + with: + name: global + path: dist/pybind11_global-* + + + + # When a GitHub release is made, upload the artifacts to PyPI + upload: + name: Upload to PyPI + runs-on: ubuntu-latest + if: github.event_name == 'release' && github.event.action == 'published' + needs: [packaging] + + steps: + - uses: actions/setup-python@v4 + with: + python-version: "3.x" + + # Downloads all to directories matching the artifact names + - uses: actions/download-artifact@v3 + + - name: Publish standard package + uses: pypa/gh-action-pypi-publish@release/v1 + with: + password: ${{ secrets.pypi_password }} + packages-dir: standard/ + + - name: Publish global package + uses: pypa/gh-action-pypi-publish@release/v1 + with: + password: ${{ secrets.pypi_password_global }} + packages-dir: global/ diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/upstream.yml b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/upstream.yml new file mode 100644 index 000000000..dd8a1c960 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.github/workflows/upstream.yml @@ -0,0 +1,116 @@ +name: Upstream + +on: + workflow_dispatch: + pull_request: + +permissions: + contents: read + +concurrency: + group: upstream-${{ github.ref }} + cancel-in-progress: true + +env: + PIP_BREAK_SYSTEM_PACKAGES: 1 + PIP_ONLY_BINARY: ":all:" + # For cmake: + VERBOSE: 1 + +jobs: + standard: + name: "🐍 3.12 latest • ubuntu-latest • x64" + runs-on: ubuntu-latest + # Only runs when the 'python dev' label is selected + if: "contains(github.event.pull_request.labels.*.name, 'python dev')" + + steps: + - uses: actions/checkout@v3 + + - name: Setup Python 3.12 + uses: actions/setup-python@v4 + with: + python-version: "3.12-dev" + + - name: Setup Boost + run: sudo apt-get install libboost-dev + + - name: Update CMake + uses: jwlawson/actions-setup-cmake@v1.14 + + - name: Run pip installs + run: | + python -m pip install --upgrade pip + python -m pip install -r tests/requirements.txt + + - name: Show platform info + run: | + python -m platform + cmake --version + pip list + + # First build - C++11 mode and inplace + - name: Configure C++11 + run: > + cmake -S . -B build11 + -DPYBIND11_WERROR=ON + -DDOWNLOAD_CATCH=ON + -DDOWNLOAD_EIGEN=ON + -DCMAKE_CXX_STANDARD=11 + -DCMAKE_BUILD_TYPE=Debug + + - name: Build C++11 + run: cmake --build build11 -j 2 + + - name: Python tests C++11 + run: cmake --build build11 --target pytest -j 2 + + - name: C++11 tests + run: cmake --build build11 --target cpptest -j 2 + + - name: Interface test C++11 + run: cmake --build build11 --target test_cmake_build + + # Second build - C++17 mode and in a build directory + - name: Configure C++17 + run: > + cmake -S . -B build17 + -DPYBIND11_WERROR=ON + -DDOWNLOAD_CATCH=ON + -DDOWNLOAD_EIGEN=ON + -DCMAKE_CXX_STANDARD=17 + + - name: Build C++17 + run: cmake --build build17 -j 2 + + - name: Python tests C++17 + run: cmake --build build17 --target pytest + + - name: C++17 tests + run: cmake --build build17 --target cpptest + + # Third build - C++17 mode with unstable ABI + - name: Configure (unstable ABI) + run: > + cmake -S . -B build17max + -DPYBIND11_WERROR=ON + -DDOWNLOAD_CATCH=ON + -DDOWNLOAD_EIGEN=ON + -DCMAKE_CXX_STANDARD=17 + -DPYBIND11_INTERNALS_VERSION=10000000 + + - name: Build (unstable ABI) + run: cmake --build build17max -j 2 + + - name: Python tests (unstable ABI) + run: cmake --build build17max --target pytest + + - name: Interface test (unstable ABI) + run: cmake --build build17max --target test_cmake_build + + # This makes sure the setup_helpers module can build packages using + # setuptools + - name: Setuptools helpers test + run: | + pip install setuptools + pytest tests/extra_setuptools diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.gitignore b/lzero/mcts/ctree/ctree_alphazero/pybind11/.gitignore new file mode 100644 index 000000000..43d5094c9 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.gitignore @@ -0,0 +1,46 @@ +CMakeCache.txt +CMakeFiles +Makefile +cmake_install.cmake +cmake_uninstall.cmake +.DS_Store +*.so +*.pyd +*.dll +*.sln +*.sdf +*.opensdf +*.vcxproj +*.vcxproj.user +*.filters +example.dir +Win32 +x64 +Release +Debug +.vs +CTestTestfile.cmake +Testing +autogen +MANIFEST +/.ninja_* +/*.ninja +/docs/.build +*.py[co] +*.egg-info +*~ +.*.swp +.DS_Store +/dist +/*build* +.cache/ +sosize-*.txt +pybind11Config*.cmake +pybind11Targets.cmake +/*env* +/.vscode +/pybind11/include/* +/pybind11/share/* +/docs/_build/* +.ipynb_checkpoints/ +tests/main.cpp diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.pre-commit-config.yaml b/lzero/mcts/ctree/ctree_alphazero/pybind11/.pre-commit-config.yaml new file mode 100644 index 000000000..86ac965d9 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.pre-commit-config.yaml @@ -0,0 +1,153 @@ +# To use: +# +# pre-commit run -a +# +# Or: +# +# pre-commit install # (runs every time you commit in git) +# +# To update this file: +# +# pre-commit autoupdate +# +# See https://github.com/pre-commit/pre-commit + + +ci: + autoupdate_commit_msg: "chore(deps): update pre-commit hooks" + autofix_commit_msg: "style: pre-commit fixes" + autoupdate_schedule: monthly + +# third-party content +exclude: ^tools/JoinPaths.cmake$ + +repos: + +# Clang format the codebase automatically +- repo: https://github.com/pre-commit/mirrors-clang-format + rev: "v16.0.6" + hooks: + - id: clang-format + types_or: [c++, c, cuda] + +# Black, the code formatter, natively supports pre-commit +- repo: https://github.com/psf/black + rev: "23.3.0" # Keep in sync with blacken-docs + hooks: + - id: black + +# Ruff, the Python auto-correcting linter written in Rust +- repo: https://github.com/astral-sh/ruff-pre-commit + rev: v0.0.276 + hooks: + - id: ruff + args: ["--fix", "--show-fixes"] + +# Check static types with mypy +- repo: https://github.com/pre-commit/mirrors-mypy + rev: "v1.4.1" + hooks: + - id: mypy + args: [] + exclude: ^(tests|docs)/ + additional_dependencies: + - markdown-it-py<3 # Drop this together with dropping Python 3.7 support. + - nox + - rich + - types-setuptools + +# CMake formatting +- repo: https://github.com/cheshirekow/cmake-format-precommit + rev: "v0.6.13" + hooks: + - id: cmake-format + additional_dependencies: [pyyaml] + types: [file] + files: (\.cmake|CMakeLists.txt)(.in)?$ + +# Standard hooks +- repo: https://github.com/pre-commit/pre-commit-hooks + rev: "v4.4.0" + hooks: + - id: check-added-large-files + - id: check-case-conflict + - id: check-docstring-first + - id: check-merge-conflict + - id: check-symlinks + - id: check-toml + - id: check-yaml + - id: debug-statements + - id: end-of-file-fixer + - id: mixed-line-ending + - id: requirements-txt-fixer + - id: trailing-whitespace + +# Also code format the docs +- repo: https://github.com/asottile/blacken-docs + rev: "1.14.0" + hooks: + - id: blacken-docs + additional_dependencies: + - black==23.3.0 # keep in sync with black hook + +# Changes tabs to spaces +- repo: https://github.com/Lucas-C/pre-commit-hooks + rev: "v1.5.1" + hooks: + - id: remove-tabs + +# Avoid directional quotes +- repo: https://github.com/sirosen/texthooks + rev: "0.5.0" + hooks: + - id: fix-ligatures + - id: fix-smartquotes + +# Checking for common mistakes +- repo: https://github.com/pre-commit/pygrep-hooks + rev: "v1.10.0" + hooks: + - id: rst-backticks + - id: rst-directive-colons + - id: rst-inline-touching-normal + +# Checks the manifest for missing files (native support) +- repo: https://github.com/mgedmin/check-manifest + rev: "0.49" + hooks: + - id: check-manifest + # This is a slow hook, so only run this if --hook-stage manual is passed + stages: [manual] + additional_dependencies: [cmake, ninja] + +# Check for spelling +# Use tools/codespell_ignore_lines_from_errors.py +# to rebuild .codespell-ignore-lines +- repo: https://github.com/codespell-project/codespell + rev: "v2.2.5" + hooks: + - id: codespell + exclude: ".supp$" + args: ["-x.codespell-ignore-lines", "-Lccompiler"] + +# Check for common shell mistakes +- repo: https://github.com/shellcheck-py/shellcheck-py + rev: "v0.9.0.5" + hooks: + - id: shellcheck + +# Disallow some common capitalization mistakes +- repo: local + hooks: + - id: disallow-caps + name: Disallow improper capitalization + language: pygrep + entry: PyBind|Numpy|Cmake|CCache|PyTest + exclude: ^\.pre-commit-config.yaml$ + +# PyLint has native support - not always usable, but works for us +- repo: https://github.com/PyCQA/pylint + rev: "v3.0.0a6" + hooks: + - id: pylint + files: ^pybind11 diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/.readthedocs.yml b/lzero/mcts/ctree/ctree_alphazero/pybind11/.readthedocs.yml new file mode 100644 index 000000000..c9c61617c --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/.readthedocs.yml @@ -0,0 +1,3 @@ +python: + version: 3 +requirements_file: docs/requirements.txt diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/CMakeFiles/CMakeDirectoryInformation.cmake b/lzero/mcts/ctree/ctree_alphazero/pybind11/CMakeFiles/CMakeDirectoryInformation.cmake new file mode 100644 index 000000000..2be98086b --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/CMakeFiles/CMakeDirectoryInformation.cmake @@ -0,0 +1,16 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.18 + +# Relative path conversion top directories. +set(CMAKE_RELATIVE_PATH_TOP_SOURCE "/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero") +set(CMAKE_RELATIVE_PATH_TOP_BINARY "/Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero") + +# Force unix paths in dependencies. +set(CMAKE_FORCE_UNIX_PATHS 1) + + +# The C and CXX include file regular expressions for this directory. +set(CMAKE_C_INCLUDE_REGEX_SCAN "^.*$") +set(CMAKE_C_INCLUDE_REGEX_COMPLAIN "^$") +set(CMAKE_CXX_INCLUDE_REGEX_SCAN ${CMAKE_C_INCLUDE_REGEX_SCAN}) +set(CMAKE_CXX_INCLUDE_REGEX_COMPLAIN ${CMAKE_C_INCLUDE_REGEX_COMPLAIN}) diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/CMakeFiles/progress.marks b/lzero/mcts/ctree/ctree_alphazero/pybind11/CMakeFiles/progress.marks new file mode 100644 index 000000000..573541ac9 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/CMakeFiles/progress.marks @@ -0,0 +1 @@ +0 diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/CMakeLists.txt b/lzero/mcts/ctree/ctree_alphazero/pybind11/CMakeLists.txt new file mode 100644 index 000000000..87ec10346 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/CMakeLists.txt @@ -0,0 +1,322 @@ +# CMakeLists.txt -- Build system for the pybind11 modules +# +# Copyright (c) 2015 Wenzel Jakob +# +# All rights reserved. Use of this source code is governed by a +# BSD-style license that can be found in the LICENSE file. + +cmake_minimum_required(VERSION 3.5) + +# The `cmake_minimum_required(VERSION 3.5...3.26)` syntax does not work with +# some versions of VS that have a patched CMake 3.11. This forces us to emulate +# the behavior using the following workaround: +if(${CMAKE_VERSION} VERSION_LESS 3.26) + cmake_policy(VERSION ${CMAKE_MAJOR_VERSION}.${CMAKE_MINOR_VERSION}) +else() + cmake_policy(VERSION 3.26) +endif() + +# Avoid infinite recursion if tests include this as a subdirectory +if(DEFINED PYBIND11_MASTER_PROJECT) + return() +endif() + +# Extract project version from source +file(STRINGS "${CMAKE_CURRENT_SOURCE_DIR}/include/pybind11/detail/common.h" + pybind11_version_defines REGEX "#define PYBIND11_VERSION_(MAJOR|MINOR|PATCH) ") + +foreach(ver ${pybind11_version_defines}) + if(ver MATCHES [[#define PYBIND11_VERSION_(MAJOR|MINOR|PATCH) +([^ ]+)$]]) + set(PYBIND11_VERSION_${CMAKE_MATCH_1} "${CMAKE_MATCH_2}") + endif() +endforeach() + +if(PYBIND11_VERSION_PATCH MATCHES [[\.([a-zA-Z0-9]+)$]]) + set(pybind11_VERSION_TYPE "${CMAKE_MATCH_1}") +endif() +string(REGEX MATCH "^[0-9]+" PYBIND11_VERSION_PATCH "${PYBIND11_VERSION_PATCH}") + +project( + pybind11 + LANGUAGES CXX + VERSION "${PYBIND11_VERSION_MAJOR}.${PYBIND11_VERSION_MINOR}.${PYBIND11_VERSION_PATCH}") + +# Standard includes +include(GNUInstallDirs) +include(CMakePackageConfigHelpers) +include(CMakeDependentOption) + +if(NOT pybind11_FIND_QUIETLY) + message(STATUS "pybind11 v${pybind11_VERSION} ${pybind11_VERSION_TYPE}") +endif() + +# Check if pybind11 is being used directly or via add_subdirectory +if(CMAKE_SOURCE_DIR STREQUAL PROJECT_SOURCE_DIR) + ### Warn if not an out-of-source builds + if(CMAKE_CURRENT_SOURCE_DIR STREQUAL CMAKE_CURRENT_BINARY_DIR) + set(lines + "You are building in-place. If that is not what you intended to " + "do, you can clean the source directory with:\n" + "rm -r CMakeCache.txt CMakeFiles/ cmake_uninstall.cmake pybind11Config.cmake " + "pybind11ConfigVersion.cmake tests/CMakeFiles/\n") + message(AUTHOR_WARNING ${lines}) + endif() + + set(PYBIND11_MASTER_PROJECT ON) + + if(OSX AND CMAKE_VERSION VERSION_LESS 3.7) + # Bug in macOS CMake < 3.7 is unable to download catch + message(WARNING "CMAKE 3.7+ needed on macOS to download catch, and newer HIGHLY recommended") + elseif(WINDOWS AND CMAKE_VERSION VERSION_LESS 3.8) + # Only tested with 3.8+ in CI. + message(WARNING "CMAKE 3.8+ tested on Windows, previous versions untested") + endif() + + message(STATUS "CMake ${CMAKE_VERSION}") + + if(CMAKE_CXX_STANDARD) + set(CMAKE_CXX_EXTENSIONS OFF) + set(CMAKE_CXX_STANDARD_REQUIRED ON) + endif() + + set(pybind11_system "") + + set_property(GLOBAL PROPERTY USE_FOLDERS ON) +else() + set(PYBIND11_MASTER_PROJECT OFF) + set(pybind11_system SYSTEM) +endif() + +# Options +option(PYBIND11_INSTALL "Install pybind11 header files?" ${PYBIND11_MASTER_PROJECT}) +option(PYBIND11_TEST "Build pybind11 test suite?" ${PYBIND11_MASTER_PROJECT}) +option(PYBIND11_NOPYTHON "Disable search for Python" OFF) +option(PYBIND11_SIMPLE_GIL_MANAGEMENT + "Use simpler GIL management logic that does not support disassociation" OFF) +set(PYBIND11_INTERNALS_VERSION + "" + CACHE STRING "Override the ABI version, may be used to enable the unstable ABI.") + +if(PYBIND11_SIMPLE_GIL_MANAGEMENT) + add_compile_definitions(PYBIND11_SIMPLE_GIL_MANAGEMENT) +endif() + +cmake_dependent_option( + USE_PYTHON_INCLUDE_DIR + "Install pybind11 headers in Python include directory instead of default installation prefix" + OFF "PYBIND11_INSTALL" OFF) + +cmake_dependent_option(PYBIND11_FINDPYTHON "Force new FindPython" OFF + "NOT CMAKE_VERSION VERSION_LESS 3.12" OFF) + +# NB: when adding a header don't forget to also add it to setup.py +set(PYBIND11_HEADERS + include/pybind11/detail/class.h + include/pybind11/detail/common.h + include/pybind11/detail/descr.h + include/pybind11/detail/init.h + include/pybind11/detail/internals.h + include/pybind11/detail/type_caster_base.h + include/pybind11/detail/typeid.h + include/pybind11/attr.h + include/pybind11/buffer_info.h + include/pybind11/cast.h + include/pybind11/chrono.h + include/pybind11/common.h + include/pybind11/complex.h + include/pybind11/options.h + include/pybind11/eigen.h + include/pybind11/eigen/common.h + include/pybind11/eigen/matrix.h + include/pybind11/eigen/tensor.h + include/pybind11/embed.h + include/pybind11/eval.h + include/pybind11/gil.h + include/pybind11/iostream.h + include/pybind11/functional.h + include/pybind11/numpy.h + include/pybind11/operators.h + include/pybind11/pybind11.h + include/pybind11/pytypes.h + include/pybind11/stl.h + include/pybind11/stl_bind.h + include/pybind11/stl/filesystem.h + include/pybind11/type_caster_pyobject_ptr.h) + +# Compare with grep and warn if mismatched +if(PYBIND11_MASTER_PROJECT AND NOT CMAKE_VERSION VERSION_LESS 3.12) + file( + GLOB_RECURSE _pybind11_header_check + LIST_DIRECTORIES false + RELATIVE "${CMAKE_CURRENT_SOURCE_DIR}" + CONFIGURE_DEPENDS "include/pybind11/*.h") + set(_pybind11_here_only ${PYBIND11_HEADERS}) + set(_pybind11_disk_only ${_pybind11_header_check}) + list(REMOVE_ITEM _pybind11_here_only ${_pybind11_header_check}) + list(REMOVE_ITEM _pybind11_disk_only ${PYBIND11_HEADERS}) + if(_pybind11_here_only) + message(AUTHOR_WARNING "PYBIND11_HEADERS has extra files:" ${_pybind11_here_only}) + endif() + if(_pybind11_disk_only) + message(AUTHOR_WARNING "PYBIND11_HEADERS is missing files:" ${_pybind11_disk_only}) + endif() +endif() + +# CMake 3.12 added list(TRANSFORM PREPEND +# But we can't use it yet +string(REPLACE "include/" "${CMAKE_CURRENT_SOURCE_DIR}/include/" PYBIND11_HEADERS + "${PYBIND11_HEADERS}") + +# Cache variable so this can be used in parent projects +set(pybind11_INCLUDE_DIR + "${CMAKE_CURRENT_LIST_DIR}/include" + CACHE INTERNAL "Directory where pybind11 headers are located") + +# Backward compatible variable for add_subdirectory mode +if(NOT PYBIND11_MASTER_PROJECT) + set(PYBIND11_INCLUDE_DIR + "${pybind11_INCLUDE_DIR}" + CACHE INTERNAL "") +endif() + +# Note: when creating targets, you cannot use if statements at configure time - +# you need generator expressions, because those will be placed in the target file. +# You can also place ifs *in* the Config.in, but not here. + +# This section builds targets, but does *not* touch Python +# Non-IMPORT targets cannot be defined twice +if(NOT TARGET pybind11_headers) + # Build the headers-only target (no Python included): + # (long name used here to keep this from clashing in subdirectory mode) + add_library(pybind11_headers INTERFACE) + add_library(pybind11::pybind11_headers ALIAS pybind11_headers) # to match exported target + add_library(pybind11::headers ALIAS pybind11_headers) # easier to use/remember + + target_include_directories( + pybind11_headers ${pybind11_system} INTERFACE $ + $) + + target_compile_features(pybind11_headers INTERFACE cxx_inheriting_constructors cxx_user_literals + cxx_right_angle_brackets) + if(NOT "${PYBIND11_INTERNALS_VERSION}" STREQUAL "") + target_compile_definitions( + pybind11_headers INTERFACE "PYBIND11_INTERNALS_VERSION=${PYBIND11_INTERNALS_VERSION}") + endif() +else() + # It is invalid to install a target twice, too. + set(PYBIND11_INSTALL OFF) +endif() + +include("${CMAKE_CURRENT_SOURCE_DIR}/tools/pybind11Common.cmake") +# https://github.com/jtojnar/cmake-snips/#concatenating-paths-when-building-pkg-config-files +# TODO: cmake 3.20 adds the cmake_path() function, which obsoletes this snippet +include("${CMAKE_CURRENT_SOURCE_DIR}/tools/JoinPaths.cmake") + +# Relative directory setting +if(USE_PYTHON_INCLUDE_DIR AND DEFINED Python_INCLUDE_DIRS) + file(RELATIVE_PATH CMAKE_INSTALL_INCLUDEDIR ${CMAKE_INSTALL_PREFIX} ${Python_INCLUDE_DIRS}) +elseif(USE_PYTHON_INCLUDE_DIR AND DEFINED PYTHON_INCLUDE_DIR) + file(RELATIVE_PATH CMAKE_INSTALL_INCLUDEDIR ${CMAKE_INSTALL_PREFIX} ${PYTHON_INCLUDE_DIRS}) +endif() + +if(PYBIND11_INSTALL) + install(DIRECTORY ${pybind11_INCLUDE_DIR}/pybind11 DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}) + set(PYBIND11_CMAKECONFIG_INSTALL_DIR + "${CMAKE_INSTALL_DATAROOTDIR}/cmake/${PROJECT_NAME}" + CACHE STRING "install path for pybind11Config.cmake") + + if(IS_ABSOLUTE "${CMAKE_INSTALL_INCLUDEDIR}") + set(pybind11_INCLUDEDIR "${CMAKE_INSTALL_FULL_INCLUDEDIR}") + else() + set(pybind11_INCLUDEDIR "\$\{PACKAGE_PREFIX_DIR\}/${CMAKE_INSTALL_INCLUDEDIR}") + endif() + + configure_package_config_file( + tools/${PROJECT_NAME}Config.cmake.in "${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake" + INSTALL_DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR}) + + if(CMAKE_VERSION VERSION_LESS 3.14) + # Remove CMAKE_SIZEOF_VOID_P from ConfigVersion.cmake since the library does + # not depend on architecture specific settings or libraries. + set(_PYBIND11_CMAKE_SIZEOF_VOID_P ${CMAKE_SIZEOF_VOID_P}) + unset(CMAKE_SIZEOF_VOID_P) + + write_basic_package_version_file( + ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake + VERSION ${PROJECT_VERSION} + COMPATIBILITY AnyNewerVersion) + + set(CMAKE_SIZEOF_VOID_P ${_PYBIND11_CMAKE_SIZEOF_VOID_P}) + else() + # CMake 3.14+ natively supports header-only libraries + write_basic_package_version_file( + ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake + VERSION ${PROJECT_VERSION} + COMPATIBILITY AnyNewerVersion ARCH_INDEPENDENT) + endif() + + install( + FILES ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}Config.cmake + ${CMAKE_CURRENT_BINARY_DIR}/${PROJECT_NAME}ConfigVersion.cmake + tools/FindPythonLibsNew.cmake + tools/pybind11Common.cmake + tools/pybind11Tools.cmake + tools/pybind11NewTools.cmake + DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR}) + + if(NOT PYBIND11_EXPORT_NAME) + set(PYBIND11_EXPORT_NAME "${PROJECT_NAME}Targets") + endif() + + install(TARGETS pybind11_headers EXPORT "${PYBIND11_EXPORT_NAME}") + + install( + EXPORT "${PYBIND11_EXPORT_NAME}" + NAMESPACE "pybind11::" + DESTINATION ${PYBIND11_CMAKECONFIG_INSTALL_DIR}) + + # pkg-config support + if(NOT prefix_for_pc_file) + set(prefix_for_pc_file "${CMAKE_INSTALL_PREFIX}") + endif() + join_paths(includedir_for_pc_file "\${prefix}" "${CMAKE_INSTALL_INCLUDEDIR}") + configure_file("${CMAKE_CURRENT_SOURCE_DIR}/tools/pybind11.pc.in" + "${CMAKE_CURRENT_BINARY_DIR}/pybind11.pc" @ONLY) + install(FILES "${CMAKE_CURRENT_BINARY_DIR}/pybind11.pc" + DESTINATION "${CMAKE_INSTALL_DATAROOTDIR}/pkgconfig/") + + # Uninstall target + if(PYBIND11_MASTER_PROJECT) + configure_file("${CMAKE_CURRENT_SOURCE_DIR}/tools/cmake_uninstall.cmake.in" + "${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake" IMMEDIATE @ONLY) + + add_custom_target(uninstall COMMAND ${CMAKE_COMMAND} -P + ${CMAKE_CURRENT_BINARY_DIR}/cmake_uninstall.cmake) + endif() +endif() + +# BUILD_TESTING takes priority, but only if this is the master project +if(PYBIND11_MASTER_PROJECT AND DEFINED BUILD_TESTING) + if(BUILD_TESTING) + if(_pybind11_nopython) + message(FATAL_ERROR "Cannot activate tests in NOPYTHON mode") + else() + add_subdirectory(tests) + endif() + endif() +else() + if(PYBIND11_TEST) + if(_pybind11_nopython) + message(FATAL_ERROR "Cannot activate tests in NOPYTHON mode") + else() + add_subdirectory(tests) + endif() + endif() +endif() + +# Better symmetry with find_package(pybind11 CONFIG) mode. +if(NOT PYBIND11_MASTER_PROJECT) + set(pybind11_FOUND + TRUE + CACHE INTERNAL "True if pybind11 and all required components found on the system") +endif() diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/LICENSE b/lzero/mcts/ctree/ctree_alphazero/pybind11/LICENSE new file mode 100644 index 000000000..e466b0dfd --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/LICENSE @@ -0,0 +1,29 @@ +Copyright (c) 2016 Wenzel Jakob , All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions are met: + +1. Redistributions of source code must retain the above copyright notice, this + list of conditions and the following disclaimer. + +2. Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + +3. Neither the name of the copyright holder nor the names of its contributors + may be used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE +FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL +DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR +SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, +OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + +Please also refer to the file .github/CONTRIBUTING.md, which clarifies licensing of +external contributions to this project including patches, pull requests, etc. diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/MANIFEST.in b/lzero/mcts/ctree/ctree_alphazero/pybind11/MANIFEST.in new file mode 100644 index 000000000..7ce83c552 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/MANIFEST.in @@ -0,0 +1,6 @@ +prune tests +recursive-include pybind11/include/pybind11 *.h +recursive-include pybind11 *.py +recursive-include pybind11 py.typed +include pybind11/share/cmake/pybind11/*.cmake +include LICENSE README.rst SECURITY.md pyproject.toml setup.py setup.cfg diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/Makefile b/lzero/mcts/ctree/ctree_alphazero/pybind11/Makefile new file mode 100644 index 000000000..bf8d914af --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/Makefile @@ -0,0 +1,153 @@ +# CMAKE generated file: DO NOT EDIT! +# Generated by "Unix Makefiles" Generator, CMake Version 3.18 + +# Default target executed when no arguments are given to make. +default_target: all + +.PHONY : default_target + +# Allow only one "make -f Makefile2" at a time, but pass parallelism. +.NOTPARALLEL: + + +#============================================================================= +# Special targets provided by cmake. + +# Disable implicit rules so canonical targets will work. +.SUFFIXES: + + +# Disable VCS-based implicit rules. +% : %,v + + +# Disable VCS-based implicit rules. +% : RCS/% + + +# Disable VCS-based implicit rules. +% : RCS/%,v + + +# Disable VCS-based implicit rules. +% : SCCS/s.% + + +# Disable VCS-based implicit rules. +% : s.% + + +.SUFFIXES: .hpux_make_needs_suffix_list + + +# Command-line flag to silence nested $(MAKE). +$(VERBOSE)MAKESILENT = -s + +#Suppress display of executed commands. +$(VERBOSE).SILENT: + +# A target that is always out of date. +cmake_force: + +.PHONY : cmake_force + +#============================================================================= +# Set environment variables for the build. + +# The shell in which to execute make rules. +SHELL = /bin/sh + +# The CMake executable. +CMAKE_COMMAND = /Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/bin/cmake + +# The command to remove a file. +RM = /Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/bin/cmake -E rm -f + +# Escaping for special characters. +EQUALS = = + +# The top-level source directory on which CMake was run. +CMAKE_SOURCE_DIR = /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero + +# The top-level build directory on which CMake was run. +CMAKE_BINARY_DIR = /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero + +#============================================================================= +# Targets provided globally by CMake. + +# Special rule for the target rebuild_cache +rebuild_cache: + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake to regenerate build system..." + /Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/bin/cmake --regenerate-during-build -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) +.PHONY : rebuild_cache + +# Special rule for the target rebuild_cache +rebuild_cache/fast: rebuild_cache + +.PHONY : rebuild_cache/fast + +# Special rule for the target edit_cache +edit_cache: + @$(CMAKE_COMMAND) -E cmake_echo_color --switch=$(COLOR) --cyan "Running CMake cache editor..." + /Users/puyuan/opt/anaconda3/lib/python3.8/site-packages/cmake/data/CMake.app/Contents/bin/ccmake -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) +.PHONY : edit_cache + +# Special rule for the target edit_cache +edit_cache/fast: edit_cache + +.PHONY : edit_cache/fast + +# The main all target +all: cmake_check_build_system + cd /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero && $(CMAKE_COMMAND) -E cmake_progress_start /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/CMakeFiles /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/pybind11//CMakeFiles/progress.marks + cd /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 pybind11/all + $(CMAKE_COMMAND) -E cmake_progress_start /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/CMakeFiles 0 +.PHONY : all + +# The main clean target +clean: + cd /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 pybind11/clean +.PHONY : clean + +# The main clean target +clean/fast: clean + +.PHONY : clean/fast + +# Prepare targets for installation. +preinstall: all + cd /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 pybind11/preinstall +.PHONY : preinstall + +# Prepare targets for installation. +preinstall/fast: + cd /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero && $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 pybind11/preinstall +.PHONY : preinstall/fast + +# clear depends +depend: + cd /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 1 +.PHONY : depend + +# Help Target +help: + @echo "The following are some of the valid targets for this Makefile:" + @echo "... all (the default if no target is provided)" + @echo "... clean" + @echo "... depend" + @echo "... edit_cache" + @echo "... rebuild_cache" +.PHONY : help + + + +#============================================================================= +# Special targets to cleanup operation of make. + +# Special rule to run CMake to check the build system integrity. +# No rule that depends on this can have commands that come from listfiles +# because they might be regenerated. +cmake_check_build_system: + cd /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero && $(CMAKE_COMMAND) -S$(CMAKE_SOURCE_DIR) -B$(CMAKE_BINARY_DIR) --check-build-system CMakeFiles/Makefile.cmake 0 +.PHONY : cmake_check_build_system + diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/README.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/README.rst new file mode 100644 index 000000000..80213a406 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/README.rst @@ -0,0 +1,180 @@ +.. figure:: https://github.com/pybind/pybind11/raw/master/docs/pybind11-logo.png + :alt: pybind11 logo + +**pybind11 — Seamless operability between C++11 and Python** + +|Latest Documentation Status| |Stable Documentation Status| |Gitter chat| |GitHub Discussions| |CI| |Build status| + +|Repology| |PyPI package| |Conda-forge| |Python Versions| + +`Setuptools example `_ +• `Scikit-build example `_ +• `CMake example `_ + +.. start + + +**pybind11** is a lightweight header-only library that exposes C++ types +in Python and vice versa, mainly to create Python bindings of existing +C++ code. Its goals and syntax are similar to the excellent +`Boost.Python `_ +library by David Abrahams: to minimize boilerplate code in traditional +extension modules by inferring type information using compile-time +introspection. + +The main issue with Boost.Python—and the reason for creating such a +similar project—is Boost. Boost is an enormously large and complex suite +of utility libraries that works with almost every C++ compiler in +existence. This compatibility has its cost: arcane template tricks and +workarounds are necessary to support the oldest and buggiest of compiler +specimens. Now that C++11-compatible compilers are widely available, +this heavy machinery has become an excessively large and unnecessary +dependency. + +Think of this library as a tiny self-contained version of Boost.Python +with everything stripped away that isn't relevant for binding +generation. Without comments, the core header files only require ~4K +lines of code and depend on Python (3.6+, or PyPy) and the C++ +standard library. This compact implementation was possible thanks to +some of the new C++11 language features (specifically: tuples, lambda +functions and variadic templates). Since its creation, this library has +grown beyond Boost.Python in many ways, leading to dramatically simpler +binding code in many common situations. + +Tutorial and reference documentation is provided at +`pybind11.readthedocs.io `_. +A PDF version of the manual is available +`here `_. +And the source code is always available at +`github.com/pybind/pybind11 `_. + + +Core features +------------- + + +pybind11 can map the following core C++ features to Python: + +- Functions accepting and returning custom data structures per value, + reference, or pointer +- Instance methods and static methods +- Overloaded functions +- Instance attributes and static attributes +- Arbitrary exception types +- Enumerations +- Callbacks +- Iterators and ranges +- Custom operators +- Single and multiple inheritance +- STL data structures +- Smart pointers with reference counting like ``std::shared_ptr`` +- Internal references with correct reference counting +- C++ classes with virtual (and pure virtual) methods can be extended + in Python + +Goodies +------- + +In addition to the core functionality, pybind11 provides some extra +goodies: + +- Python 3.6+, and PyPy3 7.3 are supported with an implementation-agnostic + interface (pybind11 2.9 was the last version to support Python 2 and 3.5). + +- It is possible to bind C++11 lambda functions with captured + variables. The lambda capture data is stored inside the resulting + Python function object. + +- pybind11 uses C++11 move constructors and move assignment operators + whenever possible to efficiently transfer custom data types. + +- It's easy to expose the internal storage of custom data types through + Pythons' buffer protocols. This is handy e.g. for fast conversion + between C++ matrix classes like Eigen and NumPy without expensive + copy operations. + +- pybind11 can automatically vectorize functions so that they are + transparently applied to all entries of one or more NumPy array + arguments. + +- Python's slice-based access and assignment operations can be + supported with just a few lines of code. + +- Everything is contained in just a few header files; there is no need + to link against any additional libraries. + +- Binaries are generally smaller by a factor of at least 2 compared to + equivalent bindings generated by Boost.Python. A recent pybind11 + conversion of PyRosetta, an enormous Boost.Python binding project, + `reported `_ + a binary size reduction of **5.4x** and compile time reduction by + **5.8x**. + +- Function signatures are precomputed at compile time (using + ``constexpr``), leading to smaller binaries. + +- With little extra effort, C++ types can be pickled and unpickled + similar to regular Python objects. + +Supported compilers +------------------- + +1. Clang/LLVM 3.3 or newer (for Apple Xcode's clang, this is 5.0.0 or + newer) +2. GCC 4.8 or newer +3. Microsoft Visual Studio 2017 or newer +4. Intel classic C++ compiler 18 or newer (ICC 20.2 tested in CI) +5. Cygwin/GCC (previously tested on 2.5.1) +6. NVCC (CUDA 11.0 tested in CI) +7. NVIDIA PGI (20.9 tested in CI) + +About +----- + +This project was created by `Wenzel +Jakob `_. Significant features and/or +improvements to the code were contributed by Jonas Adler, Lori A. Burns, +Sylvain Corlay, Eric Cousineau, Aaron Gokaslan, Ralf Grosse-Kunstleve, Trent Houliston, Axel +Huebl, @hulucc, Yannick Jadoul, Sergey Lyskov, Johan Mabille, Tomasz Miąsko, +Dean Moldovan, Ben Pritchard, Jason Rhinelander, Boris Schäling, Pim +Schellart, Henry Schreiner, Ivan Smirnov, Boris Staletic, and Patrick Stewart. + +We thank Google for a generous financial contribution to the continuous +integration infrastructure used by this project. + + +Contributing +~~~~~~~~~~~~ + +See the `contributing +guide `_ +for information on building and contributing to pybind11. + +License +~~~~~~~ + +pybind11 is provided under a BSD-style license that can be found in the +`LICENSE `_ +file. By using, distributing, or contributing to this project, you agree +to the terms and conditions of this license. + +.. |Latest Documentation Status| image:: https://readthedocs.org/projects/pybind11/badge?version=latest + :target: http://pybind11.readthedocs.org/en/latest +.. |Stable Documentation Status| image:: https://img.shields.io/badge/docs-stable-blue.svg + :target: http://pybind11.readthedocs.org/en/stable +.. |Gitter chat| image:: https://img.shields.io/gitter/room/gitterHQ/gitter.svg + :target: https://gitter.im/pybind/Lobby +.. |CI| image:: https://github.com/pybind/pybind11/workflows/CI/badge.svg + :target: https://github.com/pybind/pybind11/actions +.. |Build status| image:: https://ci.appveyor.com/api/projects/status/riaj54pn4h08xy40?svg=true + :target: https://ci.appveyor.com/project/wjakob/pybind11 +.. |PyPI package| image:: https://img.shields.io/pypi/v/pybind11.svg + :target: https://pypi.org/project/pybind11/ +.. |Conda-forge| image:: https://img.shields.io/conda/vn/conda-forge/pybind11.svg + :target: https://github.com/conda-forge/pybind11-feedstock +.. |Repology| image:: https://repology.org/badge/latest-versions/python:pybind11.svg + :target: https://repology.org/project/python:pybind11/versions +.. |Python Versions| image:: https://img.shields.io/pypi/pyversions/pybind11.svg + :target: https://pypi.org/project/pybind11/ +.. |GitHub Discussions| image:: https://img.shields.io/static/v1?label=Discussions&message=Ask&color=blue&logo=github + :target: https://github.com/pybind/pybind11/discussions diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/SECURITY.md b/lzero/mcts/ctree/ctree_alphazero/pybind11/SECURITY.md new file mode 100644 index 000000000..3d74611f2 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/SECURITY.md @@ -0,0 +1,13 @@ +# Security Policy + +## Supported Versions + +Security updates are applied only to the latest release. + +## Reporting a Vulnerability + +If you have discovered a security vulnerability in this project, please report it privately. **Do not disclose it as a public issue.** This gives us time to work with you to fix the issue before public exposure, reducing the chance that the exploit will be used before a patch is released. + +Please disclose it at [security advisory](https://github.com/pybind/pybind11/security/advisories/new). + +This project is maintained by a team of volunteers on a reasonable-effort basis. As such, please give us at least 90 days to work on a fix before public exposure. diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/cmake_install.cmake b/lzero/mcts/ctree/ctree_alphazero/pybind11/cmake_install.cmake new file mode 100644 index 000000000..539107773 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/cmake_install.cmake @@ -0,0 +1,39 @@ +# Install script for directory: /Users/puyuan/code/LightZero/lzero/mcts/ctree/ctree_alphazero/pybind11 + +# Set the install prefix +if(NOT DEFINED CMAKE_INSTALL_PREFIX) + set(CMAKE_INSTALL_PREFIX "/usr/local") +endif() +string(REGEX REPLACE "/$" "" CMAKE_INSTALL_PREFIX "${CMAKE_INSTALL_PREFIX}") + +# Set the install configuration name. +if(NOT DEFINED CMAKE_INSTALL_CONFIG_NAME) + if(BUILD_TYPE) + string(REGEX REPLACE "^[^A-Za-z0-9_]+" "" + CMAKE_INSTALL_CONFIG_NAME "${BUILD_TYPE}") + else() + set(CMAKE_INSTALL_CONFIG_NAME "") + endif() + message(STATUS "Install configuration: \"${CMAKE_INSTALL_CONFIG_NAME}\"") +endif() + +# Set the component getting installed. +if(NOT CMAKE_INSTALL_COMPONENT) + if(COMPONENT) + message(STATUS "Install component: \"${COMPONENT}\"") + set(CMAKE_INSTALL_COMPONENT "${COMPONENT}") + else() + set(CMAKE_INSTALL_COMPONENT) + endif() +endif() + +# Is this installation the result of a crosscompile? +if(NOT DEFINED CMAKE_CROSSCOMPILING) + set(CMAKE_CROSSCOMPILING "FALSE") +endif() + +# Set default install directory permissions. +if(NOT DEFINED CMAKE_OBJDUMP) + set(CMAKE_OBJDUMP "/Library/Developer/CommandLineTools/usr/bin/objdump") +endif() + diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/Doxyfile b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/Doxyfile new file mode 100644 index 000000000..09138db36 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/Doxyfile @@ -0,0 +1,21 @@ +PROJECT_NAME = pybind11 +INPUT = ../include/pybind11/ +RECURSIVE = YES + +GENERATE_HTML = NO +GENERATE_LATEX = NO +GENERATE_XML = YES +XML_OUTPUT = .build/doxygenxml +XML_PROGRAMLISTING = YES + +MACRO_EXPANSION = YES +EXPAND_ONLY_PREDEF = YES +EXPAND_AS_DEFINED = PYBIND11_RUNTIME_EXCEPTION + +ALIASES = "rst=\verbatim embed:rst" +ALIASES += "endrst=\endverbatim" + +QUIET = YES +WARNINGS = YES +WARN_IF_UNDOCUMENTED = NO +PREDEFINED = PYBIND11_NOINLINE diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/Makefile b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/Makefile new file mode 100644 index 000000000..511b47c2d --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/Makefile @@ -0,0 +1,192 @@ +# Makefile for Sphinx documentation +# + +# You can set these variables from the command line. +SPHINXOPTS = +SPHINXBUILD = sphinx-build +PAPER = +BUILDDIR = .build + +# User-friendly check for sphinx-build +ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1) +$(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/) +endif + +# Internal variables. +PAPEROPT_a4 = -D latex_paper_size=a4 +PAPEROPT_letter = -D latex_paper_size=letter +ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . +# the i18n builder cannot share the environment and doctrees with the others +I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) . + +.PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest coverage gettext + +help: + @echo "Please use \`make ' where is one of" + @echo " html to make standalone HTML files" + @echo " dirhtml to make HTML files named index.html in directories" + @echo " singlehtml to make a single large HTML file" + @echo " pickle to make pickle files" + @echo " json to make JSON files" + @echo " htmlhelp to make HTML files and a HTML help project" + @echo " qthelp to make HTML files and a qthelp project" + @echo " applehelp to make an Apple Help Book" + @echo " devhelp to make HTML files and a Devhelp project" + @echo " epub to make an epub" + @echo " latex to make LaTeX files, you can set PAPER=a4 or PAPER=letter" + @echo " latexpdf to make LaTeX files and run them through pdflatex" + @echo " latexpdfja to make LaTeX files and run them through platex/dvipdfmx" + @echo " text to make text files" + @echo " man to make manual pages" + @echo " texinfo to make Texinfo files" + @echo " info to make Texinfo files and run them through makeinfo" + @echo " gettext to make PO message catalogs" + @echo " changes to make an overview of all changed/added/deprecated items" + @echo " xml to make Docutils-native XML files" + @echo " pseudoxml to make pseudoxml-XML files for display purposes" + @echo " linkcheck to check all external links for integrity" + @echo " doctest to run all doctests embedded in the documentation (if enabled)" + @echo " coverage to run coverage check of the documentation (if enabled)" + +clean: + rm -rf $(BUILDDIR)/* + +html: + $(SPHINXBUILD) -b html $(ALLSPHINXOPTS) $(BUILDDIR)/html + @echo + @echo "Build finished. The HTML pages are in $(BUILDDIR)/html." + +dirhtml: + $(SPHINXBUILD) -b dirhtml $(ALLSPHINXOPTS) $(BUILDDIR)/dirhtml + @echo + @echo "Build finished. The HTML pages are in $(BUILDDIR)/dirhtml." + +singlehtml: + $(SPHINXBUILD) -b singlehtml $(ALLSPHINXOPTS) $(BUILDDIR)/singlehtml + @echo + @echo "Build finished. The HTML page is in $(BUILDDIR)/singlehtml." + +pickle: + $(SPHINXBUILD) -b pickle $(ALLSPHINXOPTS) $(BUILDDIR)/pickle + @echo + @echo "Build finished; now you can process the pickle files." + +json: + $(SPHINXBUILD) -b json $(ALLSPHINXOPTS) $(BUILDDIR)/json + @echo + @echo "Build finished; now you can process the JSON files." + +htmlhelp: + $(SPHINXBUILD) -b htmlhelp $(ALLSPHINXOPTS) $(BUILDDIR)/htmlhelp + @echo + @echo "Build finished; now you can run HTML Help Workshop with the" \ + ".hhp project file in $(BUILDDIR)/htmlhelp." + +qthelp: + $(SPHINXBUILD) -b qthelp $(ALLSPHINXOPTS) $(BUILDDIR)/qthelp + @echo + @echo "Build finished; now you can run "qcollectiongenerator" with the" \ + ".qhcp project file in $(BUILDDIR)/qthelp, like this:" + @echo "# qcollectiongenerator $(BUILDDIR)/qthelp/pybind11.qhcp" + @echo "To view the help file:" + @echo "# assistant -collectionFile $(BUILDDIR)/qthelp/pybind11.qhc" + +applehelp: + $(SPHINXBUILD) -b applehelp $(ALLSPHINXOPTS) $(BUILDDIR)/applehelp + @echo + @echo "Build finished. The help book is in $(BUILDDIR)/applehelp." + @echo "N.B. You won't be able to view it unless you put it in" \ + "~/Library/Documentation/Help or install it in your application" \ + "bundle." + +devhelp: + $(SPHINXBUILD) -b devhelp $(ALLSPHINXOPTS) $(BUILDDIR)/devhelp + @echo + @echo "Build finished." + @echo "To view the help file:" + @echo "# mkdir -p $$HOME/.local/share/devhelp/pybind11" + @echo "# ln -s $(BUILDDIR)/devhelp $$HOME/.local/share/devhelp/pybind11" + @echo "# devhelp" + +epub: + $(SPHINXBUILD) -b epub $(ALLSPHINXOPTS) $(BUILDDIR)/epub + @echo + @echo "Build finished. The epub file is in $(BUILDDIR)/epub." + +latex: + $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex + @echo + @echo "Build finished; the LaTeX files are in $(BUILDDIR)/latex." + @echo "Run \`make' in that directory to run these through (pdf)latex" \ + "(use \`make latexpdf' here to do that automatically)." + +latexpdf: + $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex + @echo "Running LaTeX files through pdflatex..." + $(MAKE) -C $(BUILDDIR)/latex all-pdf + @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." + +latexpdfja: + $(SPHINXBUILD) -b latex $(ALLSPHINXOPTS) $(BUILDDIR)/latex + @echo "Running LaTeX files through platex and dvipdfmx..." + $(MAKE) -C $(BUILDDIR)/latex all-pdf-ja + @echo "pdflatex finished; the PDF files are in $(BUILDDIR)/latex." + +text: + $(SPHINXBUILD) -b text $(ALLSPHINXOPTS) $(BUILDDIR)/text + @echo + @echo "Build finished. The text files are in $(BUILDDIR)/text." + +man: + $(SPHINXBUILD) -b man $(ALLSPHINXOPTS) $(BUILDDIR)/man + @echo + @echo "Build finished. The manual pages are in $(BUILDDIR)/man." + +texinfo: + $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo + @echo + @echo "Build finished. The Texinfo files are in $(BUILDDIR)/texinfo." + @echo "Run \`make' in that directory to run these through makeinfo" \ + "(use \`make info' here to do that automatically)." + +info: + $(SPHINXBUILD) -b texinfo $(ALLSPHINXOPTS) $(BUILDDIR)/texinfo + @echo "Running Texinfo files through makeinfo..." + make -C $(BUILDDIR)/texinfo info + @echo "makeinfo finished; the Info files are in $(BUILDDIR)/texinfo." + +gettext: + $(SPHINXBUILD) -b gettext $(I18NSPHINXOPTS) $(BUILDDIR)/locale + @echo + @echo "Build finished. The message catalogs are in $(BUILDDIR)/locale." + +changes: + $(SPHINXBUILD) -b changes $(ALLSPHINXOPTS) $(BUILDDIR)/changes + @echo + @echo "The overview file is in $(BUILDDIR)/changes." + +linkcheck: + $(SPHINXBUILD) -b linkcheck $(ALLSPHINXOPTS) $(BUILDDIR)/linkcheck + @echo + @echo "Link check complete; look for any errors in the above output " \ + "or in $(BUILDDIR)/linkcheck/output.txt." + +doctest: + $(SPHINXBUILD) -b doctest $(ALLSPHINXOPTS) $(BUILDDIR)/doctest + @echo "Testing of doctests in the sources finished, look at the " \ + "results in $(BUILDDIR)/doctest/output.txt." + +coverage: + $(SPHINXBUILD) -b coverage $(ALLSPHINXOPTS) $(BUILDDIR)/coverage + @echo "Testing of coverage in the sources finished, look at the " \ + "results in $(BUILDDIR)/coverage/python.txt." + +xml: + $(SPHINXBUILD) -b xml $(ALLSPHINXOPTS) $(BUILDDIR)/xml + @echo + @echo "Build finished. The XML files are in $(BUILDDIR)/xml." + +pseudoxml: + $(SPHINXBUILD) -b pseudoxml $(ALLSPHINXOPTS) $(BUILDDIR)/pseudoxml + @echo + @echo "Build finished. The pseudo-XML files are in $(BUILDDIR)/pseudoxml." diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/_static/css/custom.css b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/_static/css/custom.css new file mode 100644 index 000000000..7a49a6ac4 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/_static/css/custom.css @@ -0,0 +1,3 @@ +.highlight .go { + color: #707070; +} diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/chrono.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/chrono.rst new file mode 100644 index 000000000..fbd46057a --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/chrono.rst @@ -0,0 +1,81 @@ +Chrono +====== + +When including the additional header file :file:`pybind11/chrono.h` conversions +from C++11 chrono datatypes to python datetime objects are automatically enabled. +This header also enables conversions of python floats (often from sources such +as ``time.monotonic()``, ``time.perf_counter()`` and ``time.process_time()``) +into durations. + +An overview of clocks in C++11 +------------------------------ + +A point of confusion when using these conversions is the differences between +clocks provided in C++11. There are three clock types defined by the C++11 +standard and users can define their own if needed. Each of these clocks have +different properties and when converting to and from python will give different +results. + +The first clock defined by the standard is ``std::chrono::system_clock``. This +clock measures the current date and time. However, this clock changes with to +updates to the operating system time. For example, if your time is synchronised +with a time server this clock will change. This makes this clock a poor choice +for timing purposes but good for measuring the wall time. + +The second clock defined in the standard is ``std::chrono::steady_clock``. +This clock ticks at a steady rate and is never adjusted. This makes it excellent +for timing purposes, however the value in this clock does not correspond to the +current date and time. Often this clock will be the amount of time your system +has been on, although it does not have to be. This clock will never be the same +clock as the system clock as the system clock can change but steady clocks +cannot. + +The third clock defined in the standard is ``std::chrono::high_resolution_clock``. +This clock is the clock that has the highest resolution out of the clocks in the +system. It is normally a typedef to either the system clock or the steady clock +but can be its own independent clock. This is important as when using these +conversions as the types you get in python for this clock might be different +depending on the system. +If it is a typedef of the system clock, python will get datetime objects, but if +it is a different clock they will be timedelta objects. + +Provided conversions +-------------------- + +.. rubric:: C++ to Python + +- ``std::chrono::system_clock::time_point`` → ``datetime.datetime`` + System clock times are converted to python datetime instances. They are + in the local timezone, but do not have any timezone information attached + to them (they are naive datetime objects). + +- ``std::chrono::duration`` → ``datetime.timedelta`` + Durations are converted to timedeltas, any precision in the duration + greater than microseconds is lost by rounding towards zero. + +- ``std::chrono::[other_clocks]::time_point`` → ``datetime.timedelta`` + Any clock time that is not the system clock is converted to a time delta. + This timedelta measures the time from the clocks epoch to now. + +.. rubric:: Python to C++ + +- ``datetime.datetime`` or ``datetime.date`` or ``datetime.time`` → ``std::chrono::system_clock::time_point`` + Date/time objects are converted into system clock timepoints. Any + timezone information is ignored and the type is treated as a naive + object. + +- ``datetime.timedelta`` → ``std::chrono::duration`` + Time delta are converted into durations with microsecond precision. + +- ``datetime.timedelta`` → ``std::chrono::[other_clocks]::time_point`` + Time deltas that are converted into clock timepoints are treated as + the amount of time from the start of the clocks epoch. + +- ``float`` → ``std::chrono::duration`` + Floats that are passed to C++ as durations be interpreted as a number of + seconds. These will be converted to the duration using ``duration_cast`` + from the float. + +- ``float`` → ``std::chrono::[other_clocks]::time_point`` + Floats that are passed to C++ as time points will be interpreted as the + number of seconds from the start of the clocks epoch. diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/custom.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/custom.rst new file mode 100644 index 000000000..8138cac61 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/custom.rst @@ -0,0 +1,93 @@ +Custom type casters +=================== + +In very rare cases, applications may require custom type casters that cannot be +expressed using the abstractions provided by pybind11, thus requiring raw +Python C API calls. This is fairly advanced usage and should only be pursued by +experts who are familiar with the intricacies of Python reference counting. + +The following snippets demonstrate how this works for a very simple ``inty`` +type that that should be convertible from Python types that provide a +``__int__(self)`` method. + +.. code-block:: cpp + + struct inty { long long_value; }; + + void print(inty s) { + std::cout << s.long_value << std::endl; + } + +The following Python snippet demonstrates the intended usage from the Python side: + +.. code-block:: python + + class A: + def __int__(self): + return 123 + + + from example import print + + print(A()) + +To register the necessary conversion routines, it is necessary to add an +instantiation of the ``pybind11::detail::type_caster`` template. +Although this is an implementation detail, adding an instantiation of this +type is explicitly allowed. + +.. code-block:: cpp + + namespace PYBIND11_NAMESPACE { namespace detail { + template <> struct type_caster { + public: + /** + * This macro establishes the name 'inty' in + * function signatures and declares a local variable + * 'value' of type inty + */ + PYBIND11_TYPE_CASTER(inty, const_name("inty")); + + /** + * Conversion part 1 (Python->C++): convert a PyObject into a inty + * instance or return false upon failure. The second argument + * indicates whether implicit conversions should be applied. + */ + bool load(handle src, bool) { + /* Extract PyObject from handle */ + PyObject *source = src.ptr(); + /* Try converting into a Python integer value */ + PyObject *tmp = PyNumber_Long(source); + if (!tmp) + return false; + /* Now try to convert into a C++ int */ + value.long_value = PyLong_AsLong(tmp); + Py_DECREF(tmp); + /* Ensure return code was OK (to avoid out-of-range errors etc) */ + return !(value.long_value == -1 && !PyErr_Occurred()); + } + + /** + * Conversion part 2 (C++ -> Python): convert an inty instance into + * a Python object. The second and third arguments are used to + * indicate the return value policy and parent object (for + * ``return_value_policy::reference_internal``) and are generally + * ignored by implicit casters. + */ + static handle cast(inty src, return_value_policy /* policy */, handle /* parent */) { + return PyLong_FromLong(src.long_value); + } + }; + }} // namespace PYBIND11_NAMESPACE::detail + +.. note:: + + A ``type_caster`` defined with ``PYBIND11_TYPE_CASTER(T, ...)`` requires + that ``T`` is default-constructible (``value`` is first default constructed + and then ``load()`` assigns to it). + +.. warning:: + + When using custom type casters, it's important to declare them consistently + in every compilation unit of the Python extension module. Otherwise, + undefined behavior can ensue. diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/eigen.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/eigen.rst new file mode 100644 index 000000000..a5c11a3f1 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/eigen.rst @@ -0,0 +1,310 @@ +Eigen +##### + +`Eigen `_ is C++ header-based library for dense and +sparse linear algebra. Due to its popularity and widespread adoption, pybind11 +provides transparent conversion and limited mapping support between Eigen and +Scientific Python linear algebra data types. + +To enable the built-in Eigen support you must include the optional header file +:file:`pybind11/eigen.h`. + +Pass-by-value +============= + +When binding a function with ordinary Eigen dense object arguments (for +example, ``Eigen::MatrixXd``), pybind11 will accept any input value that is +already (or convertible to) a ``numpy.ndarray`` with dimensions compatible with +the Eigen type, copy its values into a temporary Eigen variable of the +appropriate type, then call the function with this temporary variable. + +Sparse matrices are similarly copied to or from +``scipy.sparse.csr_matrix``/``scipy.sparse.csc_matrix`` objects. + +Pass-by-reference +================= + +One major limitation of the above is that every data conversion implicitly +involves a copy, which can be both expensive (for large matrices) and disallows +binding functions that change their (Matrix) arguments. Pybind11 allows you to +work around this by using Eigen's ``Eigen::Ref`` class much as you +would when writing a function taking a generic type in Eigen itself (subject to +some limitations discussed below). + +When calling a bound function accepting a ``Eigen::Ref`` +type, pybind11 will attempt to avoid copying by using an ``Eigen::Map`` object +that maps into the source ``numpy.ndarray`` data: this requires both that the +data types are the same (e.g. ``dtype='float64'`` and ``MatrixType::Scalar`` is +``double``); and that the storage is layout compatible. The latter limitation +is discussed in detail in the section below, and requires careful +consideration: by default, numpy matrices and Eigen matrices are *not* storage +compatible. + +If the numpy matrix cannot be used as is (either because its types differ, e.g. +passing an array of integers to an Eigen parameter requiring doubles, or +because the storage is incompatible), pybind11 makes a temporary copy and +passes the copy instead. + +When a bound function parameter is instead ``Eigen::Ref`` (note the +lack of ``const``), pybind11 will only allow the function to be called if it +can be mapped *and* if the numpy array is writeable (that is +``a.flags.writeable`` is true). Any access (including modification) made to +the passed variable will be transparently carried out directly on the +``numpy.ndarray``. + +This means you can write code such as the following and have it work as +expected: + +.. code-block:: cpp + + void scale_by_2(Eigen::Ref v) { + v *= 2; + } + +Note, however, that you will likely run into limitations due to numpy and +Eigen's difference default storage order for data; see the below section on +:ref:`storage_orders` for details on how to bind code that won't run into such +limitations. + +.. note:: + + Passing by reference is not supported for sparse types. + +Returning values to Python +========================== + +When returning an ordinary dense Eigen matrix type to numpy (e.g. +``Eigen::MatrixXd`` or ``Eigen::RowVectorXf``) pybind11 keeps the matrix and +returns a numpy array that directly references the Eigen matrix: no copy of the +data is performed. The numpy array will have ``array.flags.owndata`` set to +``False`` to indicate that it does not own the data, and the lifetime of the +stored Eigen matrix will be tied to the returned ``array``. + +If you bind a function with a non-reference, ``const`` return type (e.g. +``const Eigen::MatrixXd``), the same thing happens except that pybind11 also +sets the numpy array's ``writeable`` flag to false. + +If you return an lvalue reference or pointer, the usual pybind11 rules apply, +as dictated by the binding function's return value policy (see the +documentation on :ref:`return_value_policies` for full details). That means, +without an explicit return value policy, lvalue references will be copied and +pointers will be managed by pybind11. In order to avoid copying, you should +explicitly specify an appropriate return value policy, as in the following +example: + +.. code-block:: cpp + + class MyClass { + Eigen::MatrixXd big_mat = Eigen::MatrixXd::Zero(10000, 10000); + public: + Eigen::MatrixXd &getMatrix() { return big_mat; } + const Eigen::MatrixXd &viewMatrix() { return big_mat; } + }; + + // Later, in binding code: + py::class_(m, "MyClass") + .def(py::init<>()) + .def("copy_matrix", &MyClass::getMatrix) // Makes a copy! + .def("get_matrix", &MyClass::getMatrix, py::return_value_policy::reference_internal) + .def("view_matrix", &MyClass::viewMatrix, py::return_value_policy::reference_internal) + ; + +.. code-block:: python + + a = MyClass() + m = a.get_matrix() # flags.writeable = True, flags.owndata = False + v = a.view_matrix() # flags.writeable = False, flags.owndata = False + c = a.copy_matrix() # flags.writeable = True, flags.owndata = True + # m[5,6] and v[5,6] refer to the same element, c[5,6] does not. + +Note in this example that ``py::return_value_policy::reference_internal`` is +used to tie the life of the MyClass object to the life of the returned arrays. + +You may also return an ``Eigen::Ref``, ``Eigen::Map`` or other map-like Eigen +object (for example, the return value of ``matrix.block()`` and related +methods) that map into a dense Eigen type. When doing so, the default +behaviour of pybind11 is to simply reference the returned data: you must take +care to ensure that this data remains valid! You may ask pybind11 to +explicitly *copy* such a return value by using the +``py::return_value_policy::copy`` policy when binding the function. You may +also use ``py::return_value_policy::reference_internal`` or a +``py::keep_alive`` to ensure the data stays valid as long as the returned numpy +array does. + +When returning such a reference of map, pybind11 additionally respects the +readonly-status of the returned value, marking the numpy array as non-writeable +if the reference or map was itself read-only. + +.. note:: + + Sparse types are always copied when returned. + +.. _storage_orders: + +Storage orders +============== + +Passing arguments via ``Eigen::Ref`` has some limitations that you must be +aware of in order to effectively pass matrices by reference. First and +foremost is that the default ``Eigen::Ref`` class requires +contiguous storage along columns (for column-major types, the default in Eigen) +or rows if ``MatrixType`` is specifically an ``Eigen::RowMajor`` storage type. +The former, Eigen's default, is incompatible with ``numpy``'s default row-major +storage, and so you will not be able to pass numpy arrays to Eigen by reference +without making one of two changes. + +(Note that this does not apply to vectors (or column or row matrices): for such +types the "row-major" and "column-major" distinction is meaningless). + +The first approach is to change the use of ``Eigen::Ref`` to the +more general ``Eigen::Ref>`` (or similar type with a fully dynamic stride type in the +third template argument). Since this is a rather cumbersome type, pybind11 +provides a ``py::EigenDRef`` type alias for your convenience (along +with EigenDMap for the equivalent Map, and EigenDStride for just the stride +type). + +This type allows Eigen to map into any arbitrary storage order. This is not +the default in Eigen for performance reasons: contiguous storage allows +vectorization that cannot be done when storage is not known to be contiguous at +compile time. The default ``Eigen::Ref`` stride type allows non-contiguous +storage along the outer dimension (that is, the rows of a column-major matrix +or columns of a row-major matrix), but not along the inner dimension. + +This type, however, has the added benefit of also being able to map numpy array +slices. For example, the following (contrived) example uses Eigen with a numpy +slice to multiply by 2 all coefficients that are both on even rows (0, 2, 4, +...) and in columns 2, 5, or 8: + +.. code-block:: cpp + + m.def("scale", [](py::EigenDRef m, double c) { m *= c; }); + +.. code-block:: python + + # a = np.array(...) + scale_by_2(myarray[0::2, 2:9:3]) + +The second approach to avoid copying is more intrusive: rearranging the +underlying data types to not run into the non-contiguous storage problem in the +first place. In particular, that means using matrices with ``Eigen::RowMajor`` +storage, where appropriate, such as: + +.. code-block:: cpp + + using RowMatrixXd = Eigen::Matrix; + // Use RowMatrixXd instead of MatrixXd + +Now bound functions accepting ``Eigen::Ref`` arguments will be +callable with numpy's (default) arrays without involving a copying. + +You can, alternatively, change the storage order that numpy arrays use by +adding the ``order='F'`` option when creating an array: + +.. code-block:: python + + myarray = np.array(source, order="F") + +Such an object will be passable to a bound function accepting an +``Eigen::Ref`` (or similar column-major Eigen type). + +One major caveat with this approach, however, is that it is not entirely as +easy as simply flipping all Eigen or numpy usage from one to the other: some +operations may alter the storage order of a numpy array. For example, ``a2 = +array.transpose()`` results in ``a2`` being a view of ``array`` that references +the same data, but in the opposite storage order! + +While this approach allows fully optimized vectorized calculations in Eigen, it +cannot be used with array slices, unlike the first approach. + +When *returning* a matrix to Python (either a regular matrix, a reference via +``Eigen::Ref<>``, or a map/block into a matrix), no special storage +consideration is required: the created numpy array will have the required +stride that allows numpy to properly interpret the array, whatever its storage +order. + +Failing rather than copying +=========================== + +The default behaviour when binding ``Eigen::Ref`` Eigen +references is to copy matrix values when passed a numpy array that does not +conform to the element type of ``MatrixType`` or does not have a compatible +stride layout. If you want to explicitly avoid copying in such a case, you +should bind arguments using the ``py::arg().noconvert()`` annotation (as +described in the :ref:`nonconverting_arguments` documentation). + +The following example shows an example of arguments that don't allow data +copying to take place: + +.. code-block:: cpp + + // The method and function to be bound: + class MyClass { + // ... + double some_method(const Eigen::Ref &matrix) { /* ... */ } + }; + float some_function(const Eigen::Ref &big, + const Eigen::Ref &small) { + // ... + } + + // The associated binding code: + using namespace pybind11::literals; // for "arg"_a + py::class_(m, "MyClass") + // ... other class definitions + .def("some_method", &MyClass::some_method, py::arg().noconvert()); + + m.def("some_function", &some_function, + "big"_a.noconvert(), // <- Don't allow copying for this arg + "small"_a // <- This one can be copied if needed + ); + +With the above binding code, attempting to call the the ``some_method(m)`` +method on a ``MyClass`` object, or attempting to call ``some_function(m, m2)`` +will raise a ``RuntimeError`` rather than making a temporary copy of the array. +It will, however, allow the ``m2`` argument to be copied into a temporary if +necessary. + +Note that explicitly specifying ``.noconvert()`` is not required for *mutable* +Eigen references (e.g. ``Eigen::Ref`` without ``const`` on the +``MatrixXd``): mutable references will never be called with a temporary copy. + +Vectors versus column/row matrices +================================== + +Eigen and numpy have fundamentally different notions of a vector. In Eigen, a +vector is simply a matrix with the number of columns or rows set to 1 at +compile time (for a column vector or row vector, respectively). NumPy, in +contrast, has comparable 2-dimensional 1xN and Nx1 arrays, but *also* has +1-dimensional arrays of size N. + +When passing a 2-dimensional 1xN or Nx1 array to Eigen, the Eigen type must +have matching dimensions: That is, you cannot pass a 2-dimensional Nx1 numpy +array to an Eigen value expecting a row vector, or a 1xN numpy array as a +column vector argument. + +On the other hand, pybind11 allows you to pass 1-dimensional arrays of length N +as Eigen parameters. If the Eigen type can hold a column vector of length N it +will be passed as such a column vector. If not, but the Eigen type constraints +will accept a row vector, it will be passed as a row vector. (The column +vector takes precedence when both are supported, for example, when passing a +1D numpy array to a MatrixXd argument). Note that the type need not be +explicitly a vector: it is permitted to pass a 1D numpy array of size 5 to an +Eigen ``Matrix``: you would end up with a 1x5 Eigen matrix. +Passing the same to an ``Eigen::MatrixXd`` would result in a 5x1 Eigen matrix. + +When returning an Eigen vector to numpy, the conversion is ambiguous: a row +vector of length 4 could be returned as either a 1D array of length 4, or as a +2D array of size 1x4. When encountering such a situation, pybind11 compromises +by considering the returned Eigen type: if it is a compile-time vector--that +is, the type has either the number of rows or columns set to 1 at compile +time--pybind11 converts to a 1D numpy array when returning the value. For +instances that are a vector only at run-time (e.g. ``MatrixXd``, +``Matrix``), pybind11 returns the vector as a 2D array to +numpy. If this isn't want you want, you can use ``array.reshape(...)`` to get +a view of the same data in the desired dimensions. + +.. seealso:: + + The file :file:`tests/test_eigen.cpp` contains a complete example that + shows how to pass Eigen sparse and dense data types in more detail. diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/functional.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/functional.rst new file mode 100644 index 000000000..d9b460575 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/functional.rst @@ -0,0 +1,109 @@ +Functional +########## + +The following features must be enabled by including :file:`pybind11/functional.h`. + + +Callbacks and passing anonymous functions +========================================= + +The C++11 standard brought lambda functions and the generic polymorphic +function wrapper ``std::function<>`` to the C++ programming language, which +enable powerful new ways of working with functions. Lambda functions come in +two flavors: stateless lambda function resemble classic function pointers that +link to an anonymous piece of code, while stateful lambda functions +additionally depend on captured variables that are stored in an anonymous +*lambda closure object*. + +Here is a simple example of a C++ function that takes an arbitrary function +(stateful or stateless) with signature ``int -> int`` as an argument and runs +it with the value 10. + +.. code-block:: cpp + + int func_arg(const std::function &f) { + return f(10); + } + +The example below is more involved: it takes a function of signature ``int -> int`` +and returns another function of the same kind. The return value is a stateful +lambda function, which stores the value ``f`` in the capture object and adds 1 to +its return value upon execution. + +.. code-block:: cpp + + std::function func_ret(const std::function &f) { + return [f](int i) { + return f(i) + 1; + }; + } + +This example demonstrates using python named parameters in C++ callbacks which +requires using ``py::cpp_function`` as a wrapper. Usage is similar to defining +methods of classes: + +.. code-block:: cpp + + py::cpp_function func_cpp() { + return py::cpp_function([](int i) { return i+1; }, + py::arg("number")); + } + +After including the extra header file :file:`pybind11/functional.h`, it is almost +trivial to generate binding code for all of these functions. + +.. code-block:: cpp + + #include + + PYBIND11_MODULE(example, m) { + m.def("func_arg", &func_arg); + m.def("func_ret", &func_ret); + m.def("func_cpp", &func_cpp); + } + +The following interactive session shows how to call them from Python. + +.. code-block:: pycon + + $ python + >>> import example + >>> def square(i): + ... return i * i + ... + >>> example.func_arg(square) + 100L + >>> square_plus_1 = example.func_ret(square) + >>> square_plus_1(4) + 17L + >>> plus_1 = func_cpp() + >>> plus_1(number=43) + 44L + +.. warning:: + + Keep in mind that passing a function from C++ to Python (or vice versa) + will instantiate a piece of wrapper code that translates function + invocations between the two languages. Naturally, this translation + increases the computational cost of each function call somewhat. A + problematic situation can arise when a function is copied back and forth + between Python and C++ many times in a row, in which case the underlying + wrappers will accumulate correspondingly. The resulting long sequence of + C++ -> Python -> C++ -> ... roundtrips can significantly decrease + performance. + + There is one exception: pybind11 detects case where a stateless function + (i.e. a function pointer or a lambda function without captured variables) + is passed as an argument to another C++ function exposed in Python. In this + case, there is no overhead. Pybind11 will extract the underlying C++ + function pointer from the wrapped function to sidestep a potential C++ -> + Python -> C++ roundtrip. This is demonstrated in :file:`tests/test_callbacks.cpp`. + +.. note:: + + This functionality is very useful when generating bindings for callbacks in + C++ libraries (e.g. GUI libraries, asynchronous networking libraries, etc.). + + The file :file:`tests/test_callbacks.cpp` contains a complete example + that demonstrates how to work with callbacks and anonymous functions in + more detail. diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/index.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/index.rst new file mode 100644 index 000000000..3ce9ea028 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/index.rst @@ -0,0 +1,43 @@ +.. _type-conversions: + +Type conversions +################ + +Apart from enabling cross-language function calls, a fundamental problem +that a binding tool like pybind11 must address is to provide access to +native Python types in C++ and vice versa. There are three fundamentally +different ways to do this—which approach is preferable for a particular type +depends on the situation at hand. + +1. Use a native C++ type everywhere. In this case, the type must be wrapped + using pybind11-generated bindings so that Python can interact with it. + +2. Use a native Python type everywhere. It will need to be wrapped so that + C++ functions can interact with it. + +3. Use a native C++ type on the C++ side and a native Python type on the + Python side. pybind11 refers to this as a *type conversion*. + + Type conversions are the most "natural" option in the sense that native + (non-wrapped) types are used everywhere. The main downside is that a copy + of the data must be made on every Python ↔ C++ transition: this is + needed since the C++ and Python versions of the same type generally won't + have the same memory layout. + + pybind11 can perform many kinds of conversions automatically. An overview + is provided in the table ":ref:`conversion_table`". + +The following subsections discuss the differences between these options in more +detail. The main focus in this section is on type conversions, which represent +the last case of the above list. + +.. toctree:: + :maxdepth: 1 + + overview + strings + stl + functional + chrono + eigen + custom diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/overview.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/overview.rst new file mode 100644 index 000000000..011bd4c7a --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/overview.rst @@ -0,0 +1,170 @@ +Overview +######## + +.. rubric:: 1. Native type in C++, wrapper in Python + +Exposing a custom C++ type using :class:`py::class_` was covered in detail +in the :doc:`/classes` section. There, the underlying data structure is +always the original C++ class while the :class:`py::class_` wrapper provides +a Python interface. Internally, when an object like this is sent from C++ to +Python, pybind11 will just add the outer wrapper layer over the native C++ +object. Getting it back from Python is just a matter of peeling off the +wrapper. + +.. rubric:: 2. Wrapper in C++, native type in Python + +This is the exact opposite situation. Now, we have a type which is native to +Python, like a ``tuple`` or a ``list``. One way to get this data into C++ is +with the :class:`py::object` family of wrappers. These are explained in more +detail in the :doc:`/advanced/pycpp/object` section. We'll just give a quick +example here: + +.. code-block:: cpp + + void print_list(py::list my_list) { + for (auto item : my_list) + std::cout << item << " "; + } + +.. code-block:: pycon + + >>> print_list([1, 2, 3]) + 1 2 3 + +The Python ``list`` is not converted in any way -- it's just wrapped in a C++ +:class:`py::list` class. At its core it's still a Python object. Copying a +:class:`py::list` will do the usual reference-counting like in Python. +Returning the object to Python will just remove the thin wrapper. + +.. rubric:: 3. Converting between native C++ and Python types + +In the previous two cases we had a native type in one language and a wrapper in +the other. Now, we have native types on both sides and we convert between them. + +.. code-block:: cpp + + void print_vector(const std::vector &v) { + for (auto item : v) + std::cout << item << "\n"; + } + +.. code-block:: pycon + + >>> print_vector([1, 2, 3]) + 1 2 3 + +In this case, pybind11 will construct a new ``std::vector`` and copy each +element from the Python ``list``. The newly constructed object will be passed +to ``print_vector``. The same thing happens in the other direction: a new +``list`` is made to match the value returned from C++. + +Lots of these conversions are supported out of the box, as shown in the table +below. They are very convenient, but keep in mind that these conversions are +fundamentally based on copying data. This is perfectly fine for small immutable +types but it may become quite expensive for large data structures. This can be +avoided by overriding the automatic conversion with a custom wrapper (i.e. the +above-mentioned approach 1). This requires some manual effort and more details +are available in the :ref:`opaque` section. + +.. _conversion_table: + +List of all builtin conversions +------------------------------- + +The following basic data types are supported out of the box (some may require +an additional extension header to be included). To pass other data structures +as arguments and return values, refer to the section on binding :ref:`classes`. + ++------------------------------------+---------------------------+-----------------------------------+ +| Data type | Description | Header file | ++====================================+===========================+===================================+ +| ``int8_t``, ``uint8_t`` | 8-bit integers | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``int16_t``, ``uint16_t`` | 16-bit integers | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``int32_t``, ``uint32_t`` | 32-bit integers | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``int64_t``, ``uint64_t`` | 64-bit integers | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``ssize_t``, ``size_t`` | Platform-dependent size | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``float``, ``double`` | Floating point types | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``bool`` | Two-state Boolean type | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``char`` | Character literal | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``char16_t`` | UTF-16 character literal | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``char32_t`` | UTF-32 character literal | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``wchar_t`` | Wide character literal | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``const char *`` | UTF-8 string literal | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``const char16_t *`` | UTF-16 string literal | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``const char32_t *`` | UTF-32 string literal | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``const wchar_t *`` | Wide string literal | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::string`` | STL dynamic UTF-8 string | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::u16string`` | STL dynamic UTF-16 string | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::u32string`` | STL dynamic UTF-32 string | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::wstring`` | STL dynamic wide string | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::string_view``, | STL C++17 string views | :file:`pybind11/pybind11.h` | +| ``std::u16string_view``, etc. | | | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::pair`` | Pair of two custom types | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::tuple<...>`` | Arbitrary tuple of types | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::reference_wrapper<...>`` | Reference type wrapper | :file:`pybind11/pybind11.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::complex`` | Complex numbers | :file:`pybind11/complex.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::array`` | STL static array | :file:`pybind11/stl.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::vector`` | STL dynamic array | :file:`pybind11/stl.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::deque`` | STL double-ended queue | :file:`pybind11/stl.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::valarray`` | STL value array | :file:`pybind11/stl.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::list`` | STL linked list | :file:`pybind11/stl.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::map`` | STL ordered map | :file:`pybind11/stl.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::unordered_map`` | STL unordered map | :file:`pybind11/stl.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::set`` | STL ordered set | :file:`pybind11/stl.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::unordered_set`` | STL unordered set | :file:`pybind11/stl.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::optional`` | STL optional type (C++17) | :file:`pybind11/stl.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::experimental::optional`` | STL optional type (exp.) | :file:`pybind11/stl.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::variant<...>`` | Type-safe union (C++17) | :file:`pybind11/stl.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::filesystem::path`` | STL path (C++17) [#]_ | :file:`pybind11/stl/filesystem.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::function<...>`` | STL polymorphic function | :file:`pybind11/functional.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::chrono::duration<...>`` | STL time duration | :file:`pybind11/chrono.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``std::chrono::time_point<...>`` | STL date/time | :file:`pybind11/chrono.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``Eigen::Matrix<...>`` | Eigen: dense matrix | :file:`pybind11/eigen.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``Eigen::Map<...>`` | Eigen: mapped memory | :file:`pybind11/eigen.h` | ++------------------------------------+---------------------------+-----------------------------------+ +| ``Eigen::SparseMatrix<...>`` | Eigen: sparse matrix | :file:`pybind11/eigen.h` | ++------------------------------------+---------------------------+-----------------------------------+ + +.. [#] ``std::filesystem::path`` is converted to ``pathlib.Path`` and + ``os.PathLike`` is converted to ``std::filesystem::path``. diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/stl.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/stl.rst new file mode 100644 index 000000000..03d49b295 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/stl.rst @@ -0,0 +1,249 @@ +STL containers +############## + +Automatic conversion +==================== + +When including the additional header file :file:`pybind11/stl.h`, conversions +between ``std::vector<>``/``std::deque<>``/``std::list<>``/``std::array<>``/``std::valarray<>``, +``std::set<>``/``std::unordered_set<>``, and +``std::map<>``/``std::unordered_map<>`` and the Python ``list``, ``set`` and +``dict`` data structures are automatically enabled. The types ``std::pair<>`` +and ``std::tuple<>`` are already supported out of the box with just the core +:file:`pybind11/pybind11.h` header. + +The major downside of these implicit conversions is that containers must be +converted (i.e. copied) on every Python->C++ and C++->Python transition, which +can have implications on the program semantics and performance. Please read the +next sections for more details and alternative approaches that avoid this. + +.. note:: + + Arbitrary nesting of any of these types is possible. + +.. seealso:: + + The file :file:`tests/test_stl.cpp` contains a complete + example that demonstrates how to pass STL data types in more detail. + +.. _cpp17_container_casters: + +C++17 library containers +======================== + +The :file:`pybind11/stl.h` header also includes support for ``std::optional<>`` +and ``std::variant<>``. These require a C++17 compiler and standard library. +In C++14 mode, ``std::experimental::optional<>`` is supported if available. + +Various versions of these containers also exist for C++11 (e.g. in Boost). +pybind11 provides an easy way to specialize the ``type_caster`` for such +types: + +.. code-block:: cpp + + // `boost::optional` as an example -- can be any `std::optional`-like container + namespace PYBIND11_NAMESPACE { namespace detail { + template + struct type_caster> : optional_caster> {}; + }} + +The above should be placed in a header file and included in all translation units +where automatic conversion is needed. Similarly, a specialization can be provided +for custom variant types: + +.. code-block:: cpp + + // `boost::variant` as an example -- can be any `std::variant`-like container + namespace PYBIND11_NAMESPACE { namespace detail { + template + struct type_caster> : variant_caster> {}; + + // Specifies the function used to visit the variant -- `apply_visitor` instead of `visit` + template <> + struct visit_helper { + template + static auto call(Args &&...args) -> decltype(boost::apply_visitor(args...)) { + return boost::apply_visitor(args...); + } + }; + }} // namespace PYBIND11_NAMESPACE::detail + +The ``visit_helper`` specialization is not required if your ``name::variant`` provides +a ``name::visit()`` function. For any other function name, the specialization must be +included to tell pybind11 how to visit the variant. + +.. warning:: + + When converting a ``variant`` type, pybind11 follows the same rules as when + determining which function overload to call (:ref:`overload_resolution`), and + so the same caveats hold. In particular, the order in which the ``variant``'s + alternatives are listed is important, since pybind11 will try conversions in + this order. This means that, for example, when converting ``variant``, + the ``bool`` variant will never be selected, as any Python ``bool`` is already + an ``int`` and is convertible to a C++ ``int``. Changing the order of alternatives + (and using ``variant``, in this example) provides a solution. + +.. note:: + + pybind11 only supports the modern implementation of ``boost::variant`` + which makes use of variadic templates. This requires Boost 1.56 or newer. + +.. _opaque: + +Making opaque types +=================== + +pybind11 heavily relies on a template matching mechanism to convert parameters +and return values that are constructed from STL data types such as vectors, +linked lists, hash tables, etc. This even works in a recursive manner, for +instance to deal with lists of hash maps of pairs of elementary and custom +types, etc. + +However, a fundamental limitation of this approach is that internal conversions +between Python and C++ types involve a copy operation that prevents +pass-by-reference semantics. What does this mean? + +Suppose we bind the following function + +.. code-block:: cpp + + void append_1(std::vector &v) { + v.push_back(1); + } + +and call it from Python, the following happens: + +.. code-block:: pycon + + >>> v = [5, 6] + >>> append_1(v) + >>> print(v) + [5, 6] + +As you can see, when passing STL data structures by reference, modifications +are not propagated back the Python side. A similar situation arises when +exposing STL data structures using the ``def_readwrite`` or ``def_readonly`` +functions: + +.. code-block:: cpp + + /* ... definition ... */ + + class MyClass { + std::vector contents; + }; + + /* ... binding code ... */ + + py::class_(m, "MyClass") + .def(py::init<>()) + .def_readwrite("contents", &MyClass::contents); + +In this case, properties can be read and written in their entirety. However, an +``append`` operation involving such a list type has no effect: + +.. code-block:: pycon + + >>> m = MyClass() + >>> m.contents = [5, 6] + >>> print(m.contents) + [5, 6] + >>> m.contents.append(7) + >>> print(m.contents) + [5, 6] + +Finally, the involved copy operations can be costly when dealing with very +large lists. To deal with all of the above situations, pybind11 provides a +macro named ``PYBIND11_MAKE_OPAQUE(T)`` that disables the template-based +conversion machinery of types, thus rendering them *opaque*. The contents of +opaque objects are never inspected or extracted, hence they *can* be passed by +reference. For instance, to turn ``std::vector`` into an opaque type, add +the declaration + +.. code-block:: cpp + + PYBIND11_MAKE_OPAQUE(std::vector); + +before any binding code (e.g. invocations to ``class_::def()``, etc.). This +macro must be specified at the top level (and outside of any namespaces), since +it adds a template instantiation of ``type_caster``. If your binding code consists of +multiple compilation units, it must be present in every file (typically via a +common header) preceding any usage of ``std::vector``. Opaque types must +also have a corresponding ``class_`` declaration to associate them with a name +in Python, and to define a set of available operations, e.g.: + +.. code-block:: cpp + + py::class_>(m, "IntVector") + .def(py::init<>()) + .def("clear", &std::vector::clear) + .def("pop_back", &std::vector::pop_back) + .def("__len__", [](const std::vector &v) { return v.size(); }) + .def("__iter__", [](std::vector &v) { + return py::make_iterator(v.begin(), v.end()); + }, py::keep_alive<0, 1>()) /* Keep vector alive while iterator is used */ + // .... + +.. seealso:: + + The file :file:`tests/test_opaque_types.cpp` contains a complete + example that demonstrates how to create and expose opaque types using + pybind11 in more detail. + +.. _stl_bind: + +Binding STL containers +====================== + +The ability to expose STL containers as native Python objects is a fairly +common request, hence pybind11 also provides an optional header file named +:file:`pybind11/stl_bind.h` that does exactly this. The mapped containers try +to match the behavior of their native Python counterparts as much as possible. + +The following example showcases usage of :file:`pybind11/stl_bind.h`: + +.. code-block:: cpp + + // Don't forget this + #include + + PYBIND11_MAKE_OPAQUE(std::vector); + PYBIND11_MAKE_OPAQUE(std::map); + + // ... + + // later in binding code: + py::bind_vector>(m, "VectorInt"); + py::bind_map>(m, "MapStringDouble"); + +When binding STL containers pybind11 considers the types of the container's +elements to decide whether the container should be confined to the local module +(via the :ref:`module_local` feature). If the container element types are +anything other than already-bound custom types bound without +``py::module_local()`` the container binding will have ``py::module_local()`` +applied. This includes converting types such as numeric types, strings, Eigen +types; and types that have not yet been bound at the time of the stl container +binding. This module-local binding is designed to avoid potential conflicts +between module bindings (for example, from two separate modules each attempting +to bind ``std::vector`` as a python type). + +It is possible to override this behavior to force a definition to be either +module-local or global. To do so, you can pass the attributes +``py::module_local()`` (to make the binding module-local) or +``py::module_local(false)`` (to make the binding global) into the +``py::bind_vector`` or ``py::bind_map`` arguments: + +.. code-block:: cpp + + py::bind_vector>(m, "VectorInt", py::module_local(false)); + +Note, however, that such a global binding would make it impossible to load this +module at the same time as any other pybind module that also attempts to bind +the same container type (``std::vector`` in the above example). + +See :ref:`module_local` for more details on module-local bindings. + +.. seealso:: + + The file :file:`tests/test_stl_binders.cpp` shows how to use the + convenience STL container wrappers. diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/strings.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/strings.rst new file mode 100644 index 000000000..271716b4b --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/cast/strings.rst @@ -0,0 +1,296 @@ +Strings, bytes and Unicode conversions +###################################### + +Passing Python strings to C++ +============================= + +When a Python ``str`` is passed from Python to a C++ function that accepts +``std::string`` or ``char *`` as arguments, pybind11 will encode the Python +string to UTF-8. All Python ``str`` can be encoded in UTF-8, so this operation +does not fail. + +The C++ language is encoding agnostic. It is the responsibility of the +programmer to track encodings. It's often easiest to simply `use UTF-8 +everywhere `_. + +.. code-block:: c++ + + m.def("utf8_test", + [](const std::string &s) { + cout << "utf-8 is icing on the cake.\n"; + cout << s; + } + ); + m.def("utf8_charptr", + [](const char *s) { + cout << "My favorite food is\n"; + cout << s; + } + ); + +.. code-block:: pycon + + >>> utf8_test("🎂") + utf-8 is icing on the cake. + 🎂 + + >>> utf8_charptr("🍕") + My favorite food is + 🍕 + +.. note:: + + Some terminal emulators do not support UTF-8 or emoji fonts and may not + display the example above correctly. + +The results are the same whether the C++ function accepts arguments by value or +reference, and whether or not ``const`` is used. + +Passing bytes to C++ +-------------------- + +A Python ``bytes`` object will be passed to C++ functions that accept +``std::string`` or ``char*`` *without* conversion. In order to make a function +*only* accept ``bytes`` (and not ``str``), declare it as taking a ``py::bytes`` +argument. + + +Returning C++ strings to Python +=============================== + +When a C++ function returns a ``std::string`` or ``char*`` to a Python caller, +**pybind11 will assume that the string is valid UTF-8** and will decode it to a +native Python ``str``, using the same API as Python uses to perform +``bytes.decode('utf-8')``. If this implicit conversion fails, pybind11 will +raise a ``UnicodeDecodeError``. + +.. code-block:: c++ + + m.def("std_string_return", + []() { + return std::string("This string needs to be UTF-8 encoded"); + } + ); + +.. code-block:: pycon + + >>> isinstance(example.std_string_return(), str) + True + + +Because UTF-8 is inclusive of pure ASCII, there is never any issue with +returning a pure ASCII string to Python. If there is any possibility that the +string is not pure ASCII, it is necessary to ensure the encoding is valid +UTF-8. + +.. warning:: + + Implicit conversion assumes that a returned ``char *`` is null-terminated. + If there is no null terminator a buffer overrun will occur. + +Explicit conversions +-------------------- + +If some C++ code constructs a ``std::string`` that is not a UTF-8 string, one +can perform a explicit conversion and return a ``py::str`` object. Explicit +conversion has the same overhead as implicit conversion. + +.. code-block:: c++ + + // This uses the Python C API to convert Latin-1 to Unicode + m.def("str_output", + []() { + std::string s = "Send your r\xe9sum\xe9 to Alice in HR"; // Latin-1 + py::handle py_s = PyUnicode_DecodeLatin1(s.data(), s.length(), nullptr); + if (!py_s) { + throw py::error_already_set(); + } + return py::reinterpret_steal(py_s); + } + ); + +.. code-block:: pycon + + >>> str_output() + 'Send your résumé to Alice in HR' + +The `Python C API +`_ provides +several built-in codecs. Note that these all return *new* references, so +use :cpp:func:`reinterpret_steal` when converting them to a :cpp:class:`str`. + + +One could also use a third party encoding library such as libiconv to transcode +to UTF-8. + +Return C++ strings without conversion +------------------------------------- + +If the data in a C++ ``std::string`` does not represent text and should be +returned to Python as ``bytes``, then one can return the data as a +``py::bytes`` object. + +.. code-block:: c++ + + m.def("return_bytes", + []() { + std::string s("\xba\xd0\xba\xd0"); // Not valid UTF-8 + return py::bytes(s); // Return the data without transcoding + } + ); + +.. code-block:: pycon + + >>> example.return_bytes() + b'\xba\xd0\xba\xd0' + + +Note the asymmetry: pybind11 will convert ``bytes`` to ``std::string`` without +encoding, but cannot convert ``std::string`` back to ``bytes`` implicitly. + +.. code-block:: c++ + + m.def("asymmetry", + [](std::string s) { // Accepts str or bytes from Python + return s; // Looks harmless, but implicitly converts to str + } + ); + +.. code-block:: pycon + + >>> isinstance(example.asymmetry(b"have some bytes"), str) + True + + >>> example.asymmetry(b"\xba\xd0\xba\xd0") # invalid utf-8 as bytes + UnicodeDecodeError: 'utf-8' codec can't decode byte 0xba in position 0: invalid start byte + + +Wide character strings +====================== + +When a Python ``str`` is passed to a C++ function expecting ``std::wstring``, +``wchar_t*``, ``std::u16string`` or ``std::u32string``, the ``str`` will be +encoded to UTF-16 or UTF-32 depending on how the C++ compiler implements each +type, in the platform's native endianness. When strings of these types are +returned, they are assumed to contain valid UTF-16 or UTF-32, and will be +decoded to Python ``str``. + +.. code-block:: c++ + + #define UNICODE + #include + + m.def("set_window_text", + [](HWND hwnd, std::wstring s) { + // Call SetWindowText with null-terminated UTF-16 string + ::SetWindowText(hwnd, s.c_str()); + } + ); + m.def("get_window_text", + [](HWND hwnd) { + const int buffer_size = ::GetWindowTextLength(hwnd) + 1; + auto buffer = std::make_unique< wchar_t[] >(buffer_size); + + ::GetWindowText(hwnd, buffer.data(), buffer_size); + + std::wstring text(buffer.get()); + + // wstring will be converted to Python str + return text; + } + ); + +Strings in multibyte encodings such as Shift-JIS must transcoded to a +UTF-8/16/32 before being returned to Python. + + +Character literals +================== + +C++ functions that accept character literals as input will receive the first +character of a Python ``str`` as their input. If the string is longer than one +Unicode character, trailing characters will be ignored. + +When a character literal is returned from C++ (such as a ``char`` or a +``wchar_t``), it will be converted to a ``str`` that represents the single +character. + +.. code-block:: c++ + + m.def("pass_char", [](char c) { return c; }); + m.def("pass_wchar", [](wchar_t w) { return w; }); + +.. code-block:: pycon + + >>> example.pass_char("A") + 'A' + +While C++ will cast integers to character types (``char c = 0x65;``), pybind11 +does not convert Python integers to characters implicitly. The Python function +``chr()`` can be used to convert integers to characters. + +.. code-block:: pycon + + >>> example.pass_char(0x65) + TypeError + + >>> example.pass_char(chr(0x65)) + 'A' + +If the desire is to work with an 8-bit integer, use ``int8_t`` or ``uint8_t`` +as the argument type. + +Grapheme clusters +----------------- + +A single grapheme may be represented by two or more Unicode characters. For +example 'é' is usually represented as U+00E9 but can also be expressed as the +combining character sequence U+0065 U+0301 (that is, the letter 'e' followed by +a combining acute accent). The combining character will be lost if the +two-character sequence is passed as an argument, even though it renders as a +single grapheme. + +.. code-block:: pycon + + >>> example.pass_wchar("é") + 'é' + + >>> combining_e_acute = "e" + "\u0301" + + >>> combining_e_acute + 'é' + + >>> combining_e_acute == "é" + False + + >>> example.pass_wchar(combining_e_acute) + 'e' + +Normalizing combining characters before passing the character literal to C++ +may resolve *some* of these issues: + +.. code-block:: pycon + + >>> example.pass_wchar(unicodedata.normalize("NFC", combining_e_acute)) + 'é' + +In some languages (Thai for example), there are `graphemes that cannot be +expressed as a single Unicode code point +`_, so there is +no way to capture them in a C++ character type. + + +C++17 string views +================== + +C++17 string views are automatically supported when compiling in C++17 mode. +They follow the same rules for encoding and decoding as the corresponding STL +string type (for example, a ``std::u16string_view`` argument will be passed +UTF-16-encoded data, and a returned ``std::string_view`` will be decoded as +UTF-8). + +References +========== + +* `The Absolute Minimum Every Software Developer Absolutely, Positively Must Know About Unicode and Character Sets (No Excuses!) `_ +* `C++ - Using STL Strings at Win32 API Boundaries `_ diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/classes.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/classes.rst new file mode 100644 index 000000000..01a490b72 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/classes.rst @@ -0,0 +1,1335 @@ +Classes +####### + +This section presents advanced binding code for classes and it is assumed +that you are already familiar with the basics from :doc:`/classes`. + +.. _overriding_virtuals: + +Overriding virtual functions in Python +====================================== + +Suppose that a C++ class or interface has a virtual function that we'd like +to override from within Python (we'll focus on the class ``Animal``; ``Dog`` is +given as a specific example of how one would do this with traditional C++ +code). + +.. code-block:: cpp + + class Animal { + public: + virtual ~Animal() { } + virtual std::string go(int n_times) = 0; + }; + + class Dog : public Animal { + public: + std::string go(int n_times) override { + std::string result; + for (int i=0; igo(3); + } + +Normally, the binding code for these classes would look as follows: + +.. code-block:: cpp + + PYBIND11_MODULE(example, m) { + py::class_(m, "Animal") + .def("go", &Animal::go); + + py::class_(m, "Dog") + .def(py::init<>()); + + m.def("call_go", &call_go); + } + +However, these bindings are impossible to extend: ``Animal`` is not +constructible, and we clearly require some kind of "trampoline" that +redirects virtual calls back to Python. + +Defining a new type of ``Animal`` from within Python is possible but requires a +helper class that is defined as follows: + +.. code-block:: cpp + + class PyAnimal : public Animal { + public: + /* Inherit the constructors */ + using Animal::Animal; + + /* Trampoline (need one for each virtual function) */ + std::string go(int n_times) override { + PYBIND11_OVERRIDE_PURE( + std::string, /* Return type */ + Animal, /* Parent class */ + go, /* Name of function in C++ (must match Python name) */ + n_times /* Argument(s) */ + ); + } + }; + +The macro :c:macro:`PYBIND11_OVERRIDE_PURE` should be used for pure virtual +functions, and :c:macro:`PYBIND11_OVERRIDE` should be used for functions which have +a default implementation. There are also two alternate macros +:c:macro:`PYBIND11_OVERRIDE_PURE_NAME` and :c:macro:`PYBIND11_OVERRIDE_NAME` which +take a string-valued name argument between the *Parent class* and *Name of the +function* slots, which defines the name of function in Python. This is required +when the C++ and Python versions of the +function have different names, e.g. ``operator()`` vs ``__call__``. + +The binding code also needs a few minor adaptations (highlighted): + +.. code-block:: cpp + :emphasize-lines: 2,3 + + PYBIND11_MODULE(example, m) { + py::class_(m, "Animal") + .def(py::init<>()) + .def("go", &Animal::go); + + py::class_(m, "Dog") + .def(py::init<>()); + + m.def("call_go", &call_go); + } + +Importantly, pybind11 is made aware of the trampoline helper class by +specifying it as an extra template argument to :class:`class_`. (This can also +be combined with other template arguments such as a custom holder type; the +order of template types does not matter). Following this, we are able to +define a constructor as usual. + +Bindings should be made against the actual class, not the trampoline helper class. + +.. code-block:: cpp + :emphasize-lines: 3 + + py::class_(m, "Animal"); + .def(py::init<>()) + .def("go", &PyAnimal::go); /* <--- THIS IS WRONG, use &Animal::go */ + +Note, however, that the above is sufficient for allowing python classes to +extend ``Animal``, but not ``Dog``: see :ref:`virtual_and_inheritance` for the +necessary steps required to providing proper overriding support for inherited +classes. + +The Python session below shows how to override ``Animal::go`` and invoke it via +a virtual method call. + +.. code-block:: pycon + + >>> from example import * + >>> d = Dog() + >>> call_go(d) + 'woof! woof! woof! ' + >>> class Cat(Animal): + ... def go(self, n_times): + ... return "meow! " * n_times + ... + >>> c = Cat() + >>> call_go(c) + 'meow! meow! meow! ' + +If you are defining a custom constructor in a derived Python class, you *must* +ensure that you explicitly call the bound C++ constructor using ``__init__``, +*regardless* of whether it is a default constructor or not. Otherwise, the +memory for the C++ portion of the instance will be left uninitialized, which +will generally leave the C++ instance in an invalid state and cause undefined +behavior if the C++ instance is subsequently used. + +.. versionchanged:: 2.6 + The default pybind11 metaclass will throw a ``TypeError`` when it detects + that ``__init__`` was not called by a derived class. + +Here is an example: + +.. code-block:: python + + class Dachshund(Dog): + def __init__(self, name): + Dog.__init__(self) # Without this, a TypeError is raised. + self.name = name + + def bark(self): + return "yap!" + +Note that a direct ``__init__`` constructor *should be called*, and ``super()`` +should not be used. For simple cases of linear inheritance, ``super()`` +may work, but once you begin mixing Python and C++ multiple inheritance, +things will fall apart due to differences between Python's MRO and C++'s +mechanisms. + +Please take a look at the :ref:`macro_notes` before using this feature. + +.. note:: + + When the overridden type returns a reference or pointer to a type that + pybind11 converts from Python (for example, numeric values, std::string, + and other built-in value-converting types), there are some limitations to + be aware of: + + - because in these cases there is no C++ variable to reference (the value + is stored in the referenced Python variable), pybind11 provides one in + the PYBIND11_OVERRIDE macros (when needed) with static storage duration. + Note that this means that invoking the overridden method on *any* + instance will change the referenced value stored in *all* instances of + that type. + + - Attempts to modify a non-const reference will not have the desired + effect: it will change only the static cache variable, but this change + will not propagate to underlying Python instance, and the change will be + replaced the next time the override is invoked. + +.. warning:: + + The :c:macro:`PYBIND11_OVERRIDE` and accompanying macros used to be called + ``PYBIND11_OVERLOAD`` up until pybind11 v2.5.0, and :func:`get_override` + used to be called ``get_overload``. This naming was corrected and the older + macro and function names may soon be deprecated, in order to reduce + confusion with overloaded functions and methods and ``py::overload_cast`` + (see :ref:`classes`). + +.. seealso:: + + The file :file:`tests/test_virtual_functions.cpp` contains a complete + example that demonstrates how to override virtual functions using pybind11 + in more detail. + +.. _virtual_and_inheritance: + +Combining virtual functions and inheritance +=========================================== + +When combining virtual methods with inheritance, you need to be sure to provide +an override for each method for which you want to allow overrides from derived +python classes. For example, suppose we extend the above ``Animal``/``Dog`` +example as follows: + +.. code-block:: cpp + + class Animal { + public: + virtual std::string go(int n_times) = 0; + virtual std::string name() { return "unknown"; } + }; + class Dog : public Animal { + public: + std::string go(int n_times) override { + std::string result; + for (int i=0; i class PyAnimal : public AnimalBase { + public: + using AnimalBase::AnimalBase; // Inherit constructors + std::string go(int n_times) override { PYBIND11_OVERRIDE_PURE(std::string, AnimalBase, go, n_times); } + std::string name() override { PYBIND11_OVERRIDE(std::string, AnimalBase, name, ); } + }; + template class PyDog : public PyAnimal { + public: + using PyAnimal::PyAnimal; // Inherit constructors + // Override PyAnimal's pure virtual go() with a non-pure one: + std::string go(int n_times) override { PYBIND11_OVERRIDE(std::string, DogBase, go, n_times); } + std::string bark() override { PYBIND11_OVERRIDE(std::string, DogBase, bark, ); } + }; + +This technique has the advantage of requiring just one trampoline method to be +declared per virtual method and pure virtual method override. It does, +however, require the compiler to generate at least as many methods (and +possibly more, if both pure virtual and overridden pure virtual methods are +exposed, as above). + +The classes are then registered with pybind11 using: + +.. code-block:: cpp + + py::class_> animal(m, "Animal"); + py::class_> dog(m, "Dog"); + py::class_> husky(m, "Husky"); + // ... add animal, dog, husky definitions + +Note that ``Husky`` did not require a dedicated trampoline template class at +all, since it neither declares any new virtual methods nor provides any pure +virtual method implementations. + +With either the repeated-virtuals or templated trampoline methods in place, you +can now create a python class that inherits from ``Dog``: + +.. code-block:: python + + class ShihTzu(Dog): + def bark(self): + return "yip!" + +.. seealso:: + + See the file :file:`tests/test_virtual_functions.cpp` for complete examples + using both the duplication and templated trampoline approaches. + +.. _extended_aliases: + +Extended trampoline class functionality +======================================= + +.. _extended_class_functionality_forced_trampoline: + +Forced trampoline class initialisation +-------------------------------------- +The trampoline classes described in the previous sections are, by default, only +initialized when needed. More specifically, they are initialized when a python +class actually inherits from a registered type (instead of merely creating an +instance of the registered type), or when a registered constructor is only +valid for the trampoline class but not the registered class. This is primarily +for performance reasons: when the trampoline class is not needed for anything +except virtual method dispatching, not initializing the trampoline class +improves performance by avoiding needing to do a run-time check to see if the +inheriting python instance has an overridden method. + +Sometimes, however, it is useful to always initialize a trampoline class as an +intermediate class that does more than just handle virtual method dispatching. +For example, such a class might perform extra class initialization, extra +destruction operations, and might define new members and methods to enable a +more python-like interface to a class. + +In order to tell pybind11 that it should *always* initialize the trampoline +class when creating new instances of a type, the class constructors should be +declared using ``py::init_alias()`` instead of the usual +``py::init()``. This forces construction via the trampoline class, +ensuring member initialization and (eventual) destruction. + +.. seealso:: + + See the file :file:`tests/test_virtual_functions.cpp` for complete examples + showing both normal and forced trampoline instantiation. + +Different method signatures +--------------------------- +The macro's introduced in :ref:`overriding_virtuals` cover most of the standard +use cases when exposing C++ classes to Python. Sometimes it is hard or unwieldy +to create a direct one-on-one mapping between the arguments and method return +type. + +An example would be when the C++ signature contains output arguments using +references (See also :ref:`faq_reference_arguments`). Another way of solving +this is to use the method body of the trampoline class to do conversions to the +input and return of the Python method. + +The main building block to do so is the :func:`get_override`, this function +allows retrieving a method implemented in Python from within the trampoline's +methods. Consider for example a C++ method which has the signature +``bool myMethod(int32_t& value)``, where the return indicates whether +something should be done with the ``value``. This can be made convenient on the +Python side by allowing the Python function to return ``None`` or an ``int``: + +.. code-block:: cpp + + bool MyClass::myMethod(int32_t& value) + { + pybind11::gil_scoped_acquire gil; // Acquire the GIL while in this scope. + // Try to look up the overridden method on the Python side. + pybind11::function override = pybind11::get_override(this, "myMethod"); + if (override) { // method is found + auto obj = override(value); // Call the Python function. + if (py::isinstance(obj)) { // check if it returned a Python integer type + value = obj.cast(); // Cast it and assign it to the value. + return true; // Return true; value should be used. + } else { + return false; // Python returned none, return false. + } + } + return false; // Alternatively return MyClass::myMethod(value); + } + + +.. _custom_constructors: + +Custom constructors +=================== + +The syntax for binding constructors was previously introduced, but it only +works when a constructor of the appropriate arguments actually exists on the +C++ side. To extend this to more general cases, pybind11 makes it possible +to bind factory functions as constructors. For example, suppose you have a +class like this: + +.. code-block:: cpp + + class Example { + private: + Example(int); // private constructor + public: + // Factory function: + static Example create(int a) { return Example(a); } + }; + + py::class_(m, "Example") + .def(py::init(&Example::create)); + +While it is possible to create a straightforward binding of the static +``create`` method, it may sometimes be preferable to expose it as a constructor +on the Python side. This can be accomplished by calling ``.def(py::init(...))`` +with the function reference returning the new instance passed as an argument. +It is also possible to use this approach to bind a function returning a new +instance by raw pointer or by the holder (e.g. ``std::unique_ptr``). + +The following example shows the different approaches: + +.. code-block:: cpp + + class Example { + private: + Example(int); // private constructor + public: + // Factory function - returned by value: + static Example create(int a) { return Example(a); } + + // These constructors are publicly callable: + Example(double); + Example(int, int); + Example(std::string); + }; + + py::class_(m, "Example") + // Bind the factory function as a constructor: + .def(py::init(&Example::create)) + // Bind a lambda function returning a pointer wrapped in a holder: + .def(py::init([](std::string arg) { + return std::unique_ptr(new Example(arg)); + })) + // Return a raw pointer: + .def(py::init([](int a, int b) { return new Example(a, b); })) + // You can mix the above with regular C++ constructor bindings as well: + .def(py::init()) + ; + +When the constructor is invoked from Python, pybind11 will call the factory +function and store the resulting C++ instance in the Python instance. + +When combining factory functions constructors with :ref:`virtual function +trampolines ` there are two approaches. The first is to +add a constructor to the alias class that takes a base value by +rvalue-reference. If such a constructor is available, it will be used to +construct an alias instance from the value returned by the factory function. +The second option is to provide two factory functions to ``py::init()``: the +first will be invoked when no alias class is required (i.e. when the class is +being used but not inherited from in Python), and the second will be invoked +when an alias is required. + +You can also specify a single factory function that always returns an alias +instance: this will result in behaviour similar to ``py::init_alias<...>()``, +as described in the :ref:`extended trampoline class documentation +`. + +The following example shows the different factory approaches for a class with +an alias: + +.. code-block:: cpp + + #include + class Example { + public: + // ... + virtual ~Example() = default; + }; + class PyExample : public Example { + public: + using Example::Example; + PyExample(Example &&base) : Example(std::move(base)) {} + }; + py::class_(m, "Example") + // Returns an Example pointer. If a PyExample is needed, the Example + // instance will be moved via the extra constructor in PyExample, above. + .def(py::init([]() { return new Example(); })) + // Two callbacks: + .def(py::init([]() { return new Example(); } /* no alias needed */, + []() { return new PyExample(); } /* alias needed */)) + // *Always* returns an alias instance (like py::init_alias<>()) + .def(py::init([]() { return new PyExample(); })) + ; + +Brace initialization +-------------------- + +``pybind11::init<>`` internally uses C++11 brace initialization to call the +constructor of the target class. This means that it can be used to bind +*implicit* constructors as well: + +.. code-block:: cpp + + struct Aggregate { + int a; + std::string b; + }; + + py::class_(m, "Aggregate") + .def(py::init()); + +.. note:: + + Note that brace initialization preferentially invokes constructor overloads + taking a ``std::initializer_list``. In the rare event that this causes an + issue, you can work around it by using ``py::init(...)`` with a lambda + function that constructs the new object as desired. + +.. _classes_with_non_public_destructors: + +Non-public destructors +====================== + +If a class has a private or protected destructor (as might e.g. be the case in +a singleton pattern), a compile error will occur when creating bindings via +pybind11. The underlying issue is that the ``std::unique_ptr`` holder type that +is responsible for managing the lifetime of instances will reference the +destructor even if no deallocations ever take place. In order to expose classes +with private or protected destructors, it is possible to override the holder +type via a holder type argument to ``class_``. Pybind11 provides a helper class +``py::nodelete`` that disables any destructor invocations. In this case, it is +crucial that instances are deallocated on the C++ side to avoid memory leaks. + +.. code-block:: cpp + + /* ... definition ... */ + + class MyClass { + private: + ~MyClass() { } + }; + + /* ... binding code ... */ + + py::class_>(m, "MyClass") + .def(py::init<>()) + +.. _destructors_that_call_python: + +Destructors that call Python +============================ + +If a Python function is invoked from a C++ destructor, an exception may be thrown +of type :class:`error_already_set`. If this error is thrown out of a class destructor, +``std::terminate()`` will be called, terminating the process. Class destructors +must catch all exceptions of type :class:`error_already_set` to discard the Python +exception using :func:`error_already_set::discard_as_unraisable`. + +Every Python function should be treated as *possibly throwing*. When a Python generator +stops yielding items, Python will throw a ``StopIteration`` exception, which can pass +though C++ destructors if the generator's stack frame holds the last reference to C++ +objects. + +For more information, see :ref:`the documentation on exceptions `. + +.. code-block:: cpp + + class MyClass { + public: + ~MyClass() { + try { + py::print("Even printing is dangerous in a destructor"); + py::exec("raise ValueError('This is an unraisable exception')"); + } catch (py::error_already_set &e) { + // error_context should be information about where/why the occurred, + // e.g. use __func__ to get the name of the current function + e.discard_as_unraisable(__func__); + } + } + }; + +.. note:: + + pybind11 does not support C++ destructors marked ``noexcept(false)``. + +.. versionadded:: 2.6 + +.. _implicit_conversions: + +Implicit conversions +==================== + +Suppose that instances of two types ``A`` and ``B`` are used in a project, and +that an ``A`` can easily be converted into an instance of type ``B`` (examples of this +could be a fixed and an arbitrary precision number type). + +.. code-block:: cpp + + py::class_(m, "A") + /// ... members ... + + py::class_(m, "B") + .def(py::init()) + /// ... members ... + + m.def("func", + [](const B &) { /* .... */ } + ); + +To invoke the function ``func`` using a variable ``a`` containing an ``A`` +instance, we'd have to write ``func(B(a))`` in Python. On the other hand, C++ +will automatically apply an implicit type conversion, which makes it possible +to directly write ``func(a)``. + +In this situation (i.e. where ``B`` has a constructor that converts from +``A``), the following statement enables similar implicit conversions on the +Python side: + +.. code-block:: cpp + + py::implicitly_convertible(); + +.. note:: + + Implicit conversions from ``A`` to ``B`` only work when ``B`` is a custom + data type that is exposed to Python via pybind11. + + To prevent runaway recursion, implicit conversions are non-reentrant: an + implicit conversion invoked as part of another implicit conversion of the + same type (i.e. from ``A`` to ``B``) will fail. + +.. _static_properties: + +Static properties +================= + +The section on :ref:`properties` discussed the creation of instance properties +that are implemented in terms of C++ getters and setters. + +Static properties can also be created in a similar way to expose getters and +setters of static class attributes. Note that the implicit ``self`` argument +also exists in this case and is used to pass the Python ``type`` subclass +instance. This parameter will often not be needed by the C++ side, and the +following example illustrates how to instantiate a lambda getter function +that ignores it: + +.. code-block:: cpp + + py::class_(m, "Foo") + .def_property_readonly_static("foo", [](py::object /* self */) { return Foo(); }); + +Operator overloading +==================== + +Suppose that we're given the following ``Vector2`` class with a vector addition +and scalar multiplication operation, all implemented using overloaded operators +in C++. + +.. code-block:: cpp + + class Vector2 { + public: + Vector2(float x, float y) : x(x), y(y) { } + + Vector2 operator+(const Vector2 &v) const { return Vector2(x + v.x, y + v.y); } + Vector2 operator*(float value) const { return Vector2(x * value, y * value); } + Vector2& operator+=(const Vector2 &v) { x += v.x; y += v.y; return *this; } + Vector2& operator*=(float v) { x *= v; y *= v; return *this; } + + friend Vector2 operator*(float f, const Vector2 &v) { + return Vector2(f * v.x, f * v.y); + } + + std::string toString() const { + return "[" + std::to_string(x) + ", " + std::to_string(y) + "]"; + } + private: + float x, y; + }; + +The following snippet shows how the above operators can be conveniently exposed +to Python. + +.. code-block:: cpp + + #include + + PYBIND11_MODULE(example, m) { + py::class_(m, "Vector2") + .def(py::init()) + .def(py::self + py::self) + .def(py::self += py::self) + .def(py::self *= float()) + .def(float() * py::self) + .def(py::self * float()) + .def(-py::self) + .def("__repr__", &Vector2::toString); + } + +Note that a line like + +.. code-block:: cpp + + .def(py::self * float()) + +is really just short hand notation for + +.. code-block:: cpp + + .def("__mul__", [](const Vector2 &a, float b) { + return a * b; + }, py::is_operator()) + +This can be useful for exposing additional operators that don't exist on the +C++ side, or to perform other types of customization. The ``py::is_operator`` +flag marker is needed to inform pybind11 that this is an operator, which +returns ``NotImplemented`` when invoked with incompatible arguments rather than +throwing a type error. + +.. note:: + + To use the more convenient ``py::self`` notation, the additional + header file :file:`pybind11/operators.h` must be included. + +.. seealso:: + + The file :file:`tests/test_operator_overloading.cpp` contains a + complete example that demonstrates how to work with overloaded operators in + more detail. + +.. _pickling: + +Pickling support +================ + +Python's ``pickle`` module provides a powerful facility to serialize and +de-serialize a Python object graph into a binary data stream. To pickle and +unpickle C++ classes using pybind11, a ``py::pickle()`` definition must be +provided. Suppose the class in question has the following signature: + +.. code-block:: cpp + + class Pickleable { + public: + Pickleable(const std::string &value) : m_value(value) { } + const std::string &value() const { return m_value; } + + void setExtra(int extra) { m_extra = extra; } + int extra() const { return m_extra; } + private: + std::string m_value; + int m_extra = 0; + }; + +Pickling support in Python is enabled by defining the ``__setstate__`` and +``__getstate__`` methods [#f3]_. For pybind11 classes, use ``py::pickle()`` +to bind these two functions: + +.. code-block:: cpp + + py::class_(m, "Pickleable") + .def(py::init()) + .def("value", &Pickleable::value) + .def("extra", &Pickleable::extra) + .def("setExtra", &Pickleable::setExtra) + .def(py::pickle( + [](const Pickleable &p) { // __getstate__ + /* Return a tuple that fully encodes the state of the object */ + return py::make_tuple(p.value(), p.extra()); + }, + [](py::tuple t) { // __setstate__ + if (t.size() != 2) + throw std::runtime_error("Invalid state!"); + + /* Create a new C++ instance */ + Pickleable p(t[0].cast()); + + /* Assign any additional state */ + p.setExtra(t[1].cast()); + + return p; + } + )); + +The ``__setstate__`` part of the ``py::pickle()`` definition follows the same +rules as the single-argument version of ``py::init()``. The return type can be +a value, pointer or holder type. See :ref:`custom_constructors` for details. + +An instance can now be pickled as follows: + +.. code-block:: python + + import pickle + + p = Pickleable("test_value") + p.setExtra(15) + data = pickle.dumps(p) + + +.. note:: + If given, the second argument to ``dumps`` must be 2 or larger - 0 and 1 are + not supported. Newer versions are also fine; for instance, specify ``-1`` to + always use the latest available version. Beware: failure to follow these + instructions will cause important pybind11 memory allocation routines to be + skipped during unpickling, which will likely lead to memory corruption + and/or segmentation faults. Python defaults to version 3 (Python 3-3.7) and + version 4 for Python 3.8+. + +.. seealso:: + + The file :file:`tests/test_pickling.cpp` contains a complete example + that demonstrates how to pickle and unpickle types using pybind11 in more + detail. + +.. [#f3] http://docs.python.org/3/library/pickle.html#pickling-class-instances + +Deepcopy support +================ + +Python normally uses references in assignments. Sometimes a real copy is needed +to prevent changing all copies. The ``copy`` module [#f5]_ provides these +capabilities. + +A class with pickle support is automatically also (deep)copy +compatible. However, performance can be improved by adding custom +``__copy__`` and ``__deepcopy__`` methods. + +For simple classes (deep)copy can be enabled by using the copy constructor, +which should look as follows: + +.. code-block:: cpp + + py::class_(m, "Copyable") + .def("__copy__", [](const Copyable &self) { + return Copyable(self); + }) + .def("__deepcopy__", [](const Copyable &self, py::dict) { + return Copyable(self); + }, "memo"_a); + +.. note:: + + Dynamic attributes will not be copied in this example. + +.. [#f5] https://docs.python.org/3/library/copy.html + +Multiple Inheritance +==================== + +pybind11 can create bindings for types that derive from multiple base types +(aka. *multiple inheritance*). To do so, specify all bases in the template +arguments of the ``class_`` declaration: + +.. code-block:: cpp + + py::class_(m, "MyType") + ... + +The base types can be specified in arbitrary order, and they can even be +interspersed with alias types and holder types (discussed earlier in this +document)---pybind11 will automatically find out which is which. The only +requirement is that the first template argument is the type to be declared. + +It is also permitted to inherit multiply from exported C++ classes in Python, +as well as inheriting from multiple Python and/or pybind11-exported classes. + +There is one caveat regarding the implementation of this feature: + +When only one base type is specified for a C++ type that actually has multiple +bases, pybind11 will assume that it does not participate in multiple +inheritance, which can lead to undefined behavior. In such cases, add the tag +``multiple_inheritance`` to the class constructor: + +.. code-block:: cpp + + py::class_(m, "MyType", py::multiple_inheritance()); + +The tag is redundant and does not need to be specified when multiple base types +are listed. + +.. _module_local: + +Module-local class bindings +=========================== + +When creating a binding for a class, pybind11 by default makes that binding +"global" across modules. What this means is that a type defined in one module +can be returned from any module resulting in the same Python type. For +example, this allows the following: + +.. code-block:: cpp + + // In the module1.cpp binding code for module1: + py::class_(m, "Pet") + .def(py::init()) + .def_readonly("name", &Pet::name); + +.. code-block:: cpp + + // In the module2.cpp binding code for module2: + m.def("create_pet", [](std::string name) { return new Pet(name); }); + +.. code-block:: pycon + + >>> from module1 import Pet + >>> from module2 import create_pet + >>> pet1 = Pet("Kitty") + >>> pet2 = create_pet("Doggy") + >>> pet2.name() + 'Doggy' + +When writing binding code for a library, this is usually desirable: this +allows, for example, splitting up a complex library into multiple Python +modules. + +In some cases, however, this can cause conflicts. For example, suppose two +unrelated modules make use of an external C++ library and each provide custom +bindings for one of that library's classes. This will result in an error when +a Python program attempts to import both modules (directly or indirectly) +because of conflicting definitions on the external type: + +.. code-block:: cpp + + // dogs.cpp + + // Binding for external library class: + py::class(m, "Pet") + .def("name", &pets::Pet::name); + + // Binding for local extension class: + py::class(m, "Dog") + .def(py::init()); + +.. code-block:: cpp + + // cats.cpp, in a completely separate project from the above dogs.cpp. + + // Binding for external library class: + py::class(m, "Pet") + .def("get_name", &pets::Pet::name); + + // Binding for local extending class: + py::class(m, "Cat") + .def(py::init()); + +.. code-block:: pycon + + >>> import cats + >>> import dogs + Traceback (most recent call last): + File "", line 1, in + ImportError: generic_type: type "Pet" is already registered! + +To get around this, you can tell pybind11 to keep the external class binding +localized to the module by passing the ``py::module_local()`` attribute into +the ``py::class_`` constructor: + +.. code-block:: cpp + + // Pet binding in dogs.cpp: + py::class(m, "Pet", py::module_local()) + .def("name", &pets::Pet::name); + +.. code-block:: cpp + + // Pet binding in cats.cpp: + py::class(m, "Pet", py::module_local()) + .def("get_name", &pets::Pet::name); + +This makes the Python-side ``dogs.Pet`` and ``cats.Pet`` into distinct classes, +avoiding the conflict and allowing both modules to be loaded. C++ code in the +``dogs`` module that casts or returns a ``Pet`` instance will result in a +``dogs.Pet`` Python instance, while C++ code in the ``cats`` module will result +in a ``cats.Pet`` Python instance. + +This does come with two caveats, however: First, external modules cannot return +or cast a ``Pet`` instance to Python (unless they also provide their own local +bindings). Second, from the Python point of view they are two distinct classes. + +Note that the locality only applies in the C++ -> Python direction. When +passing such a ``py::module_local`` type into a C++ function, the module-local +classes are still considered. This means that if the following function is +added to any module (including but not limited to the ``cats`` and ``dogs`` +modules above) it will be callable with either a ``dogs.Pet`` or ``cats.Pet`` +argument: + +.. code-block:: cpp + + m.def("pet_name", [](const pets::Pet &pet) { return pet.name(); }); + +For example, suppose the above function is added to each of ``cats.cpp``, +``dogs.cpp`` and ``frogs.cpp`` (where ``frogs.cpp`` is some other module that +does *not* bind ``Pets`` at all). + +.. code-block:: pycon + + >>> import cats, dogs, frogs # No error because of the added py::module_local() + >>> mycat, mydog = cats.Cat("Fluffy"), dogs.Dog("Rover") + >>> (cats.pet_name(mycat), dogs.pet_name(mydog)) + ('Fluffy', 'Rover') + >>> (cats.pet_name(mydog), dogs.pet_name(mycat), frogs.pet_name(mycat)) + ('Rover', 'Fluffy', 'Fluffy') + +It is possible to use ``py::module_local()`` registrations in one module even +if another module registers the same type globally: within the module with the +module-local definition, all C++ instances will be cast to the associated bound +Python type. In other modules any such values are converted to the global +Python type created elsewhere. + +.. note:: + + STL bindings (as provided via the optional :file:`pybind11/stl_bind.h` + header) apply ``py::module_local`` by default when the bound type might + conflict with other modules; see :ref:`stl_bind` for details. + +.. note:: + + The localization of the bound types is actually tied to the shared object + or binary generated by the compiler/linker. For typical modules created + with ``PYBIND11_MODULE()``, this distinction is not significant. It is + possible, however, when :ref:`embedding` to embed multiple modules in the + same binary (see :ref:`embedding_modules`). In such a case, the + localization will apply across all embedded modules within the same binary. + +.. seealso:: + + The file :file:`tests/test_local_bindings.cpp` contains additional examples + that demonstrate how ``py::module_local()`` works. + +Binding protected member functions +================================== + +It's normally not possible to expose ``protected`` member functions to Python: + +.. code-block:: cpp + + class A { + protected: + int foo() const { return 42; } + }; + + py::class_(m, "A") + .def("foo", &A::foo); // error: 'foo' is a protected member of 'A' + +On one hand, this is good because non-``public`` members aren't meant to be +accessed from the outside. But we may want to make use of ``protected`` +functions in derived Python classes. + +The following pattern makes this possible: + +.. code-block:: cpp + + class A { + protected: + int foo() const { return 42; } + }; + + class Publicist : public A { // helper type for exposing protected functions + public: + using A::foo; // inherited with different access modifier + }; + + py::class_(m, "A") // bind the primary class + .def("foo", &Publicist::foo); // expose protected methods via the publicist + +This works because ``&Publicist::foo`` is exactly the same function as +``&A::foo`` (same signature and address), just with a different access +modifier. The only purpose of the ``Publicist`` helper class is to make +the function name ``public``. + +If the intent is to expose ``protected`` ``virtual`` functions which can be +overridden in Python, the publicist pattern can be combined with the previously +described trampoline: + +.. code-block:: cpp + + class A { + public: + virtual ~A() = default; + + protected: + virtual int foo() const { return 42; } + }; + + class Trampoline : public A { + public: + int foo() const override { PYBIND11_OVERRIDE(int, A, foo, ); } + }; + + class Publicist : public A { + public: + using A::foo; + }; + + py::class_(m, "A") // <-- `Trampoline` here + .def("foo", &Publicist::foo); // <-- `Publicist` here, not `Trampoline`! + +Binding final classes +===================== + +Some classes may not be appropriate to inherit from. In C++11, classes can +use the ``final`` specifier to ensure that a class cannot be inherited from. +The ``py::is_final`` attribute can be used to ensure that Python classes +cannot inherit from a specified type. The underlying C++ type does not need +to be declared final. + +.. code-block:: cpp + + class IsFinal final {}; + + py::class_(m, "IsFinal", py::is_final()); + +When you try to inherit from such a class in Python, you will now get this +error: + +.. code-block:: pycon + + >>> class PyFinalChild(IsFinal): + ... pass + ... + TypeError: type 'IsFinal' is not an acceptable base type + +.. note:: This attribute is currently ignored on PyPy + +.. versionadded:: 2.6 + +Binding classes with template parameters +======================================== + +pybind11 can also wrap classes that have template parameters. Consider these classes: + +.. code-block:: cpp + + struct Cat {}; + struct Dog {}; + + template + struct Cage { + Cage(PetType& pet); + PetType& get(); + }; + +C++ templates may only be instantiated at compile time, so pybind11 can only +wrap instantiated templated classes. You cannot wrap a non-instantiated template: + +.. code-block:: cpp + + // BROKEN (this will not compile) + py::class_(m, "Cage"); + .def("get", &Cage::get); + +You must explicitly specify each template/type combination that you want to +wrap separately. + +.. code-block:: cpp + + // ok + py::class_>(m, "CatCage") + .def("get", &Cage::get); + + // ok + py::class_>(m, "DogCage") + .def("get", &Cage::get); + +If your class methods have template parameters you can wrap those as well, +but once again each instantiation must be explicitly specified: + +.. code-block:: cpp + + typename + struct MyClass { + template + T fn(V v); + }; + + py::class>(m, "MyClassT") + .def("fn", &MyClass::fn); + +Custom automatic downcasters +============================ + +As explained in :ref:`inheritance`, pybind11 comes with built-in +understanding of the dynamic type of polymorphic objects in C++; that +is, returning a Pet to Python produces a Python object that knows it's +wrapping a Dog, if Pet has virtual methods and pybind11 knows about +Dog and this Pet is in fact a Dog. Sometimes, you might want to +provide this automatic downcasting behavior when creating bindings for +a class hierarchy that does not use standard C++ polymorphism, such as +LLVM [#f4]_. As long as there's some way to determine at runtime +whether a downcast is safe, you can proceed by specializing the +``pybind11::polymorphic_type_hook`` template: + +.. code-block:: cpp + + enum class PetKind { Cat, Dog, Zebra }; + struct Pet { // Not polymorphic: has no virtual methods + const PetKind kind; + int age = 0; + protected: + Pet(PetKind _kind) : kind(_kind) {} + }; + struct Dog : Pet { + Dog() : Pet(PetKind::Dog) {} + std::string sound = "woof!"; + std::string bark() const { return sound; } + }; + + namespace PYBIND11_NAMESPACE { + template<> struct polymorphic_type_hook { + static const void *get(const Pet *src, const std::type_info*& type) { + // note that src may be nullptr + if (src && src->kind == PetKind::Dog) { + type = &typeid(Dog); + return static_cast(src); + } + return src; + } + }; + } // namespace PYBIND11_NAMESPACE + +When pybind11 wants to convert a C++ pointer of type ``Base*`` to a +Python object, it calls ``polymorphic_type_hook::get()`` to +determine if a downcast is possible. The ``get()`` function should use +whatever runtime information is available to determine if its ``src`` +parameter is in fact an instance of some class ``Derived`` that +inherits from ``Base``. If it finds such a ``Derived``, it sets ``type += &typeid(Derived)`` and returns a pointer to the ``Derived`` object +that contains ``src``. Otherwise, it just returns ``src``, leaving +``type`` at its default value of nullptr. If you set ``type`` to a +type that pybind11 doesn't know about, no downcasting will occur, and +the original ``src`` pointer will be used with its static type +``Base*``. + +It is critical that the returned pointer and ``type`` argument of +``get()`` agree with each other: if ``type`` is set to something +non-null, the returned pointer must point to the start of an object +whose type is ``type``. If the hierarchy being exposed uses only +single inheritance, a simple ``return src;`` will achieve this just +fine, but in the general case, you must cast ``src`` to the +appropriate derived-class pointer (e.g. using +``static_cast(src)``) before allowing it to be returned as a +``void*``. + +.. [#f4] https://llvm.org/docs/HowToSetUpLLVMStyleRTTI.html + +.. note:: + + pybind11's standard support for downcasting objects whose types + have virtual methods is implemented using + ``polymorphic_type_hook`` too, using the standard C++ ability to + determine the most-derived type of a polymorphic object using + ``typeid()`` and to cast a base pointer to that most-derived type + (even if you don't know what it is) using ``dynamic_cast``. + +.. seealso:: + + The file :file:`tests/test_tagbased_polymorphic.cpp` contains a + more complete example, including a demonstration of how to provide + automatic downcasting for an entire class hierarchy without + writing one get() function for each class. + +Accessing the type object +========================= + +You can get the type object from a C++ class that has already been registered using: + +.. code-block:: cpp + + py::type T_py = py::type::of(); + +You can directly use ``py::type::of(ob)`` to get the type object from any python +object, just like ``type(ob)`` in Python. + +.. note:: + + Other types, like ``py::type::of()``, do not work, see :ref:`type-conversions`. + +.. versionadded:: 2.6 + +Custom type setup +================= + +For advanced use cases, such as enabling garbage collection support, you may +wish to directly manipulate the ``PyHeapTypeObject`` corresponding to a +``py::class_`` definition. + +You can do that using ``py::custom_type_setup``: + +.. code-block:: cpp + + struct OwnsPythonObjects { + py::object value = py::none(); + }; + py::class_ cls( + m, "OwnsPythonObjects", py::custom_type_setup([](PyHeapTypeObject *heap_type) { + auto *type = &heap_type->ht_type; + type->tp_flags |= Py_TPFLAGS_HAVE_GC; + type->tp_traverse = [](PyObject *self_base, visitproc visit, void *arg) { + auto &self = py::cast(py::handle(self_base)); + Py_VISIT(self.value.ptr()); + return 0; + }; + type->tp_clear = [](PyObject *self_base) { + auto &self = py::cast(py::handle(self_base)); + self.value = py::none(); + return 0; + }; + })); + cls.def(py::init<>()); + cls.def_readwrite("value", &OwnsPythonObjects::value); + +.. versionadded:: 2.8 diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/embedding.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/embedding.rst new file mode 100644 index 000000000..e6a1686f8 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/embedding.rst @@ -0,0 +1,262 @@ +.. _embedding: + +Embedding the interpreter +######################### + +While pybind11 is mainly focused on extending Python using C++, it's also +possible to do the reverse: embed the Python interpreter into a C++ program. +All of the other documentation pages still apply here, so refer to them for +general pybind11 usage. This section will cover a few extra things required +for embedding. + +Getting started +=============== + +A basic executable with an embedded interpreter can be created with just a few +lines of CMake and the ``pybind11::embed`` target, as shown below. For more +information, see :doc:`/compiling`. + +.. code-block:: cmake + + cmake_minimum_required(VERSION 3.5...3.26) + project(example) + + find_package(pybind11 REQUIRED) # or `add_subdirectory(pybind11)` + + add_executable(example main.cpp) + target_link_libraries(example PRIVATE pybind11::embed) + +The essential structure of the ``main.cpp`` file looks like this: + +.. code-block:: cpp + + #include // everything needed for embedding + namespace py = pybind11; + + int main() { + py::scoped_interpreter guard{}; // start the interpreter and keep it alive + + py::print("Hello, World!"); // use the Python API + } + +The interpreter must be initialized before using any Python API, which includes +all the functions and classes in pybind11. The RAII guard class ``scoped_interpreter`` +takes care of the interpreter lifetime. After the guard is destroyed, the interpreter +shuts down and clears its memory. No Python functions can be called after this. + +Executing Python code +===================== + +There are a few different ways to run Python code. One option is to use ``eval``, +``exec`` or ``eval_file``, as explained in :ref:`eval`. Here is a quick example in +the context of an executable with an embedded interpreter: + +.. code-block:: cpp + + #include + namespace py = pybind11; + + int main() { + py::scoped_interpreter guard{}; + + py::exec(R"( + kwargs = dict(name="World", number=42) + message = "Hello, {name}! The answer is {number}".format(**kwargs) + print(message) + )"); + } + +Alternatively, similar results can be achieved using pybind11's API (see +:doc:`/advanced/pycpp/index` for more details). + +.. code-block:: cpp + + #include + namespace py = pybind11; + using namespace py::literals; + + int main() { + py::scoped_interpreter guard{}; + + auto kwargs = py::dict("name"_a="World", "number"_a=42); + auto message = "Hello, {name}! The answer is {number}"_s.format(**kwargs); + py::print(message); + } + +The two approaches can also be combined: + +.. code-block:: cpp + + #include + #include + + namespace py = pybind11; + using namespace py::literals; + + int main() { + py::scoped_interpreter guard{}; + + auto locals = py::dict("name"_a="World", "number"_a=42); + py::exec(R"( + message = "Hello, {name}! The answer is {number}".format(**locals()) + )", py::globals(), locals); + + auto message = locals["message"].cast(); + std::cout << message; + } + +Importing modules +================= + +Python modules can be imported using ``module_::import()``: + +.. code-block:: cpp + + py::module_ sys = py::module_::import("sys"); + py::print(sys.attr("path")); + +For convenience, the current working directory is included in ``sys.path`` when +embedding the interpreter. This makes it easy to import local Python files: + +.. code-block:: python + + """calc.py located in the working directory""" + + + def add(i, j): + return i + j + + +.. code-block:: cpp + + py::module_ calc = py::module_::import("calc"); + py::object result = calc.attr("add")(1, 2); + int n = result.cast(); + assert(n == 3); + +Modules can be reloaded using ``module_::reload()`` if the source is modified e.g. +by an external process. This can be useful in scenarios where the application +imports a user defined data processing script which needs to be updated after +changes by the user. Note that this function does not reload modules recursively. + +.. _embedding_modules: + +Adding embedded modules +======================= + +Embedded binary modules can be added using the ``PYBIND11_EMBEDDED_MODULE`` macro. +Note that the definition must be placed at global scope. They can be imported +like any other module. + +.. code-block:: cpp + + #include + namespace py = pybind11; + + PYBIND11_EMBEDDED_MODULE(fast_calc, m) { + // `m` is a `py::module_` which is used to bind functions and classes + m.def("add", [](int i, int j) { + return i + j; + }); + } + + int main() { + py::scoped_interpreter guard{}; + + auto fast_calc = py::module_::import("fast_calc"); + auto result = fast_calc.attr("add")(1, 2).cast(); + assert(result == 3); + } + +Unlike extension modules where only a single binary module can be created, on +the embedded side an unlimited number of modules can be added using multiple +``PYBIND11_EMBEDDED_MODULE`` definitions (as long as they have unique names). + +These modules are added to Python's list of builtins, so they can also be +imported in pure Python files loaded by the interpreter. Everything interacts +naturally: + +.. code-block:: python + + """py_module.py located in the working directory""" + import cpp_module + + a = cpp_module.a + b = a + 1 + + +.. code-block:: cpp + + #include + namespace py = pybind11; + + PYBIND11_EMBEDDED_MODULE(cpp_module, m) { + m.attr("a") = 1; + } + + int main() { + py::scoped_interpreter guard{}; + + auto py_module = py::module_::import("py_module"); + + auto locals = py::dict("fmt"_a="{} + {} = {}", **py_module.attr("__dict__")); + assert(locals["a"].cast() == 1); + assert(locals["b"].cast() == 2); + + py::exec(R"( + c = a + b + message = fmt.format(a, b, c) + )", py::globals(), locals); + + assert(locals["c"].cast() == 3); + assert(locals["message"].cast() == "1 + 2 = 3"); + } + + +Interpreter lifetime +==================== + +The Python interpreter shuts down when ``scoped_interpreter`` is destroyed. After +this, creating a new instance will restart the interpreter. Alternatively, the +``initialize_interpreter`` / ``finalize_interpreter`` pair of functions can be used +to directly set the state at any time. + +Modules created with pybind11 can be safely re-initialized after the interpreter +has been restarted. However, this may not apply to third-party extension modules. +The issue is that Python itself cannot completely unload extension modules and +there are several caveats with regard to interpreter restarting. In short, not +all memory may be freed, either due to Python reference cycles or user-created +global data. All the details can be found in the CPython documentation. + +.. warning:: + + Creating two concurrent ``scoped_interpreter`` guards is a fatal error. So is + calling ``initialize_interpreter`` for a second time after the interpreter + has already been initialized. + + Do not use the raw CPython API functions ``Py_Initialize`` and + ``Py_Finalize`` as these do not properly handle the lifetime of + pybind11's internal data. + + +Sub-interpreter support +======================= + +Creating multiple copies of ``scoped_interpreter`` is not possible because it +represents the main Python interpreter. Sub-interpreters are something different +and they do permit the existence of multiple interpreters. This is an advanced +feature of the CPython API and should be handled with care. pybind11 does not +currently offer a C++ interface for sub-interpreters, so refer to the CPython +documentation for all the details regarding this feature. + +We'll just mention a couple of caveats the sub-interpreters support in pybind11: + + 1. Sub-interpreters will not receive independent copies of embedded modules. + Instead, these are shared and modifications in one interpreter may be + reflected in another. + + 2. Managing multiple threads, multiple interpreters and the GIL can be + challenging and there are several caveats here, even within the pure + CPython API (please refer to the Python docs for details). As for + pybind11, keep in mind that ``gil_scoped_release`` and ``gil_scoped_acquire`` + do not take sub-interpreters into account. diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/exceptions.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/exceptions.rst new file mode 100644 index 000000000..53981dc08 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/exceptions.rst @@ -0,0 +1,401 @@ +Exceptions +########## + +Built-in C++ to Python exception translation +============================================ + +When Python calls C++ code through pybind11, pybind11 provides a C++ exception handler +that will trap C++ exceptions, translate them to the corresponding Python exception, +and raise them so that Python code can handle them. + +pybind11 defines translations for ``std::exception`` and its standard +subclasses, and several special exception classes that translate to specific +Python exceptions. Note that these are not actually Python exceptions, so they +cannot be examined using the Python C API. Instead, they are pure C++ objects +that pybind11 will translate the corresponding Python exception when they arrive +at its exception handler. + +.. tabularcolumns:: |p{0.5\textwidth}|p{0.45\textwidth}| + ++--------------------------------------+--------------------------------------+ +| Exception thrown by C++ | Translated to Python exception type | ++======================================+======================================+ +| :class:`std::exception` | ``RuntimeError`` | ++--------------------------------------+--------------------------------------+ +| :class:`std::bad_alloc` | ``MemoryError`` | ++--------------------------------------+--------------------------------------+ +| :class:`std::domain_error` | ``ValueError`` | ++--------------------------------------+--------------------------------------+ +| :class:`std::invalid_argument` | ``ValueError`` | ++--------------------------------------+--------------------------------------+ +| :class:`std::length_error` | ``ValueError`` | ++--------------------------------------+--------------------------------------+ +| :class:`std::out_of_range` | ``IndexError`` | ++--------------------------------------+--------------------------------------+ +| :class:`std::range_error` | ``ValueError`` | ++--------------------------------------+--------------------------------------+ +| :class:`std::overflow_error` | ``OverflowError`` | ++--------------------------------------+--------------------------------------+ +| :class:`pybind11::stop_iteration` | ``StopIteration`` (used to implement | +| | custom iterators) | ++--------------------------------------+--------------------------------------+ +| :class:`pybind11::index_error` | ``IndexError`` (used to indicate out | +| | of bounds access in ``__getitem__``, | +| | ``__setitem__``, etc.) | ++--------------------------------------+--------------------------------------+ +| :class:`pybind11::key_error` | ``KeyError`` (used to indicate out | +| | of bounds access in ``__getitem__``, | +| | ``__setitem__`` in dict-like | +| | objects, etc.) | ++--------------------------------------+--------------------------------------+ +| :class:`pybind11::value_error` | ``ValueError`` (used to indicate | +| | wrong value passed in | +| | ``container.remove(...)``) | ++--------------------------------------+--------------------------------------+ +| :class:`pybind11::type_error` | ``TypeError`` | ++--------------------------------------+--------------------------------------+ +| :class:`pybind11::buffer_error` | ``BufferError`` | ++--------------------------------------+--------------------------------------+ +| :class:`pybind11::import_error` | ``ImportError`` | ++--------------------------------------+--------------------------------------+ +| :class:`pybind11::attribute_error` | ``AttributeError`` | ++--------------------------------------+--------------------------------------+ +| Any other exception | ``RuntimeError`` | ++--------------------------------------+--------------------------------------+ + +Exception translation is not bidirectional. That is, *catching* the C++ +exceptions defined above will not trap exceptions that originate from +Python. For that, catch :class:`pybind11::error_already_set`. See :ref:`below +` for further details. + +There is also a special exception :class:`cast_error` that is thrown by +:func:`handle::call` when the input arguments cannot be converted to Python +objects. + +Registering custom translators +============================== + +If the default exception conversion policy described above is insufficient, +pybind11 also provides support for registering custom exception translators. +Similar to pybind11 classes, exception translators can be local to the module +they are defined in or global to the entire python session. To register a simple +exception conversion that translates a C++ exception into a new Python exception +using the C++ exception's ``what()`` method, a helper function is available: + +.. code-block:: cpp + + py::register_exception(module, "PyExp"); + +This call creates a Python exception class with the name ``PyExp`` in the given +module and automatically converts any encountered exceptions of type ``CppExp`` +into Python exceptions of type ``PyExp``. + +A matching function is available for registering a local exception translator: + +.. code-block:: cpp + + py::register_local_exception(module, "PyExp"); + + +It is possible to specify base class for the exception using the third +parameter, a ``handle``: + +.. code-block:: cpp + + py::register_exception(module, "PyExp", PyExc_RuntimeError); + py::register_local_exception(module, "PyExp", PyExc_RuntimeError); + +Then ``PyExp`` can be caught both as ``PyExp`` and ``RuntimeError``. + +The class objects of the built-in Python exceptions are listed in the Python +documentation on `Standard Exceptions `_. +The default base class is ``PyExc_Exception``. + +When more advanced exception translation is needed, the functions +``py::register_exception_translator(translator)`` and +``py::register_local_exception_translator(translator)`` can be used to register +functions that can translate arbitrary exception types (and which may include +additional logic to do so). The functions takes a stateless callable (e.g. a +function pointer or a lambda function without captured variables) with the call +signature ``void(std::exception_ptr)``. + +When a C++ exception is thrown, the registered exception translators are tried +in reverse order of registration (i.e. the last registered translator gets the +first shot at handling the exception). All local translators will be tried +before a global translator is tried. + +Inside the translator, ``std::rethrow_exception`` should be used within +a try block to re-throw the exception. One or more catch clauses to catch +the appropriate exceptions should then be used with each clause using +``PyErr_SetString`` to set a Python exception or ``ex(string)`` to set +the python exception to a custom exception type (see below). + +To declare a custom Python exception type, declare a ``py::exception`` variable +and use this in the associated exception translator (note: it is often useful +to make this a static declaration when using it inside a lambda expression +without requiring capturing). + +The following example demonstrates this for a hypothetical exception classes +``MyCustomException`` and ``OtherException``: the first is translated to a +custom python exception ``MyCustomError``, while the second is translated to a +standard python RuntimeError: + +.. code-block:: cpp + + static py::exception exc(m, "MyCustomError"); + py::register_exception_translator([](std::exception_ptr p) { + try { + if (p) std::rethrow_exception(p); + } catch (const MyCustomException &e) { + exc(e.what()); + } catch (const OtherException &e) { + PyErr_SetString(PyExc_RuntimeError, e.what()); + } + }); + +Multiple exceptions can be handled by a single translator, as shown in the +example above. If the exception is not caught by the current translator, the +previously registered one gets a chance. + +If none of the registered exception translators is able to handle the +exception, it is handled by the default converter as described in the previous +section. + +.. seealso:: + + The file :file:`tests/test_exceptions.cpp` contains examples + of various custom exception translators and custom exception types. + +.. note:: + + Call either ``PyErr_SetString`` or a custom exception's call + operator (``exc(string)``) for every exception caught in a custom exception + translator. Failure to do so will cause Python to crash with ``SystemError: + error return without exception set``. + + Exceptions that you do not plan to handle should simply not be caught, or + may be explicitly (re-)thrown to delegate it to the other, + previously-declared existing exception translators. + + Note that ``libc++`` and ``libstdc++`` `behave differently under macOS + `_ + with ``-fvisibility=hidden``. Therefore exceptions that are used across ABI + boundaries need to be explicitly exported, as exercised in + ``tests/test_exceptions.h``. See also: + "Problems with C++ exceptions" under `GCC Wiki `_. + + +Local vs Global Exception Translators +===================================== + +When a global exception translator is registered, it will be applied across all +modules in the reverse order of registration. This can create behavior where the +order of module import influences how exceptions are translated. + +If module1 has the following translator: + +.. code-block:: cpp + + py::register_exception_translator([](std::exception_ptr p) { + try { + if (p) std::rethrow_exception(p); + } catch (const std::invalid_argument &e) { + PyErr_SetString("module1 handled this") + } + } + +and module2 has the following similar translator: + +.. code-block:: cpp + + py::register_exception_translator([](std::exception_ptr p) { + try { + if (p) std::rethrow_exception(p); + } catch (const std::invalid_argument &e) { + PyErr_SetString("module2 handled this") + } + } + +then which translator handles the invalid_argument will be determined by the +order that module1 and module2 are imported. Since exception translators are +applied in the reverse order of registration, which ever module was imported +last will "win" and that translator will be applied. + +If there are multiple pybind11 modules that share exception types (either +standard built-in or custom) loaded into a single python instance and +consistent error handling behavior is needed, then local translators should be +used. + +Changing the previous example to use ``register_local_exception_translator`` +would mean that when invalid_argument is thrown in the module2 code, the +module2 translator will always handle it, while in module1, the module1 +translator will do the same. + +.. _handling_python_exceptions_cpp: + +Handling exceptions from Python in C++ +====================================== + +When C++ calls Python functions, such as in a callback function or when +manipulating Python objects, and Python raises an ``Exception``, pybind11 +converts the Python exception into a C++ exception of type +:class:`pybind11::error_already_set` whose payload contains a C++ string textual +summary and the actual Python exception. ``error_already_set`` is used to +propagate Python exception back to Python (or possibly, handle them in C++). + +.. tabularcolumns:: |p{0.5\textwidth}|p{0.45\textwidth}| + ++--------------------------------------+--------------------------------------+ +| Exception raised in Python | Thrown as C++ exception type | ++======================================+======================================+ +| Any Python ``Exception`` | :class:`pybind11::error_already_set` | ++--------------------------------------+--------------------------------------+ + +For example: + +.. code-block:: cpp + + try { + // open("missing.txt", "r") + auto file = py::module_::import("io").attr("open")("missing.txt", "r"); + auto text = file.attr("read")(); + file.attr("close")(); + } catch (py::error_already_set &e) { + if (e.matches(PyExc_FileNotFoundError)) { + py::print("missing.txt not found"); + } else if (e.matches(PyExc_PermissionError)) { + py::print("missing.txt found but not accessible"); + } else { + throw; + } + } + +Note that C++ to Python exception translation does not apply here, since that is +a method for translating C++ exceptions to Python, not vice versa. The error raised +from Python is always ``error_already_set``. + +This example illustrates this behavior: + +.. code-block:: cpp + + try { + py::eval("raise ValueError('The Ring')"); + } catch (py::value_error &boromir) { + // Boromir never gets the ring + assert(false); + } catch (py::error_already_set &frodo) { + // Frodo gets the ring + py::print("I will take the ring"); + } + + try { + // py::value_error is a request for pybind11 to raise a Python exception + throw py::value_error("The ball"); + } catch (py::error_already_set &cat) { + // cat won't catch the ball since + // py::value_error is not a Python exception + assert(false); + } catch (py::value_error &dog) { + // dog will catch the ball + py::print("Run Spot run"); + throw; // Throw it again (pybind11 will raise ValueError) + } + +Handling errors from the Python C API +===================================== + +Where possible, use :ref:`pybind11 wrappers ` instead of calling +the Python C API directly. When calling the Python C API directly, in +addition to manually managing reference counts, one must follow the pybind11 +error protocol, which is outlined here. + +After calling the Python C API, if Python returns an error, +``throw py::error_already_set();``, which allows pybind11 to deal with the +exception and pass it back to the Python interpreter. This includes calls to +the error setting functions such as ``PyErr_SetString``. + +.. code-block:: cpp + + PyErr_SetString(PyExc_TypeError, "C API type error demo"); + throw py::error_already_set(); + + // But it would be easier to simply... + throw py::type_error("pybind11 wrapper type error"); + +Alternately, to ignore the error, call `PyErr_Clear +`_. + +Any Python error must be thrown or cleared, or Python/pybind11 will be left in +an invalid state. + +Chaining exceptions ('raise from') +================================== + +Python has a mechanism for indicating that exceptions were caused by other +exceptions: + +.. code-block:: py + + try: + print(1 / 0) + except Exception as exc: + raise RuntimeError("could not divide by zero") from exc + +To do a similar thing in pybind11, you can use the ``py::raise_from`` function. It +sets the current python error indicator, so to continue propagating the exception +you should ``throw py::error_already_set()``. + +.. code-block:: cpp + + try { + py::eval("print(1 / 0")); + } catch (py::error_already_set &e) { + py::raise_from(e, PyExc_RuntimeError, "could not divide by zero"); + throw py::error_already_set(); + } + +.. versionadded:: 2.8 + +.. _unraisable_exceptions: + +Handling unraisable exceptions +============================== + +If a Python function invoked from a C++ destructor or any function marked +``noexcept(true)`` (collectively, "noexcept functions") throws an exception, there +is no way to propagate the exception, as such functions may not throw. +Should they throw or fail to catch any exceptions in their call graph, +the C++ runtime calls ``std::terminate()`` to abort immediately. + +Similarly, Python exceptions raised in a class's ``__del__`` method do not +propagate, but are logged by Python as an unraisable error. In Python 3.8+, a +`system hook is triggered +`_ +and an auditing event is logged. + +Any noexcept function should have a try-catch block that traps +class:`error_already_set` (or any other exception that can occur). Note that +pybind11 wrappers around Python exceptions such as +:class:`pybind11::value_error` are *not* Python exceptions; they are C++ +exceptions that pybind11 catches and converts to Python exceptions. Noexcept +functions cannot propagate these exceptions either. A useful approach is to +convert them to Python exceptions and then ``discard_as_unraisable`` as shown +below. + +.. code-block:: cpp + + void nonthrowing_func() noexcept(true) { + try { + // ... + } catch (py::error_already_set &eas) { + // Discard the Python error using Python APIs, using the C++ magic + // variable __func__. Python already knows the type and value and of the + // exception object. + eas.discard_as_unraisable(__func__); + } catch (const std::exception &e) { + // Log and discard C++ exceptions. + third_party::log(e); + } + } + +.. versionadded:: 2.6 diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/functions.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/functions.rst new file mode 100644 index 000000000..69e3d8a1d --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/functions.rst @@ -0,0 +1,614 @@ +Functions +######### + +Before proceeding with this section, make sure that you are already familiar +with the basics of binding functions and classes, as explained in :doc:`/basics` +and :doc:`/classes`. The following guide is applicable to both free and member +functions, i.e. *methods* in Python. + +.. _return_value_policies: + +Return value policies +===================== + +Python and C++ use fundamentally different ways of managing the memory and +lifetime of objects managed by them. This can lead to issues when creating +bindings for functions that return a non-trivial type. Just by looking at the +type information, it is not clear whether Python should take charge of the +returned value and eventually free its resources, or if this is handled on the +C++ side. For this reason, pybind11 provides a several *return value policy* +annotations that can be passed to the :func:`module_::def` and +:func:`class_::def` functions. The default policy is +:enum:`return_value_policy::automatic`. + +Return value policies are tricky, and it's very important to get them right. +Just to illustrate what can go wrong, consider the following simple example: + +.. code-block:: cpp + + /* Function declaration */ + Data *get_data() { return _data; /* (pointer to a static data structure) */ } + ... + + /* Binding code */ + m.def("get_data", &get_data); // <-- KABOOM, will cause crash when called from Python + +What's going on here? When ``get_data()`` is called from Python, the return +value (a native C++ type) must be wrapped to turn it into a usable Python type. +In this case, the default return value policy (:enum:`return_value_policy::automatic`) +causes pybind11 to assume ownership of the static ``_data`` instance. + +When Python's garbage collector eventually deletes the Python +wrapper, pybind11 will also attempt to delete the C++ instance (via ``operator +delete()``) due to the implied ownership. At this point, the entire application +will come crashing down, though errors could also be more subtle and involve +silent data corruption. + +In the above example, the policy :enum:`return_value_policy::reference` should have +been specified so that the global data instance is only *referenced* without any +implied transfer of ownership, i.e.: + +.. code-block:: cpp + + m.def("get_data", &get_data, py::return_value_policy::reference); + +On the other hand, this is not the right policy for many other situations, +where ignoring ownership could lead to resource leaks. +As a developer using pybind11, it's important to be familiar with the different +return value policies, including which situation calls for which one of them. +The following table provides an overview of available policies: + +.. tabularcolumns:: |p{0.5\textwidth}|p{0.45\textwidth}| + ++--------------------------------------------------+----------------------------------------------------------------------------+ +| Return value policy | Description | ++==================================================+============================================================================+ +| :enum:`return_value_policy::take_ownership` | Reference an existing object (i.e. do not create a new copy) and take | +| | ownership. Python will call the destructor and delete operator when the | +| | object's reference count reaches zero. Undefined behavior ensues when the | +| | C++ side does the same, or when the data was not dynamically allocated. | ++--------------------------------------------------+----------------------------------------------------------------------------+ +| :enum:`return_value_policy::copy` | Create a new copy of the returned object, which will be owned by Python. | +| | This policy is comparably safe because the lifetimes of the two instances | +| | are decoupled. | ++--------------------------------------------------+----------------------------------------------------------------------------+ +| :enum:`return_value_policy::move` | Use ``std::move`` to move the return value contents into a new instance | +| | that will be owned by Python. This policy is comparably safe because the | +| | lifetimes of the two instances (move source and destination) are decoupled.| ++--------------------------------------------------+----------------------------------------------------------------------------+ +| :enum:`return_value_policy::reference` | Reference an existing object, but do not take ownership. The C++ side is | +| | responsible for managing the object's lifetime and deallocating it when | +| | it is no longer used. Warning: undefined behavior will ensue when the C++ | +| | side deletes an object that is still referenced and used by Python. | ++--------------------------------------------------+----------------------------------------------------------------------------+ +| :enum:`return_value_policy::reference_internal` | Indicates that the lifetime of the return value is tied to the lifetime | +| | of a parent object, namely the implicit ``this``, or ``self`` argument of | +| | the called method or property. Internally, this policy works just like | +| | :enum:`return_value_policy::reference` but additionally applies a | +| | ``keep_alive<0, 1>`` *call policy* (described in the next section) that | +| | prevents the parent object from being garbage collected as long as the | +| | return value is referenced by Python. This is the default policy for | +| | property getters created via ``def_property``, ``def_readwrite``, etc. | ++--------------------------------------------------+----------------------------------------------------------------------------+ +| :enum:`return_value_policy::automatic` | This policy falls back to the policy | +| | :enum:`return_value_policy::take_ownership` when the return value is a | +| | pointer. Otherwise, it uses :enum:`return_value_policy::move` or | +| | :enum:`return_value_policy::copy` for rvalue and lvalue references, | +| | respectively. See above for a description of what all of these different | +| | policies do. This is the default policy for ``py::class_``-wrapped types. | ++--------------------------------------------------+----------------------------------------------------------------------------+ +| :enum:`return_value_policy::automatic_reference` | As above, but use policy :enum:`return_value_policy::reference` when the | +| | return value is a pointer. This is the default conversion policy for | +| | function arguments when calling Python functions manually from C++ code | +| | (i.e. via ``handle::operator()``) and the casters in ``pybind11/stl.h``. | +| | You probably won't need to use this explicitly. | ++--------------------------------------------------+----------------------------------------------------------------------------+ + +Return value policies can also be applied to properties: + +.. code-block:: cpp + + class_(m, "MyClass") + .def_property("data", &MyClass::getData, &MyClass::setData, + py::return_value_policy::copy); + +Technically, the code above applies the policy to both the getter and the +setter function, however, the setter doesn't really care about *return* +value policies which makes this a convenient terse syntax. Alternatively, +targeted arguments can be passed through the :class:`cpp_function` constructor: + +.. code-block:: cpp + + class_(m, "MyClass") + .def_property("data", + py::cpp_function(&MyClass::getData, py::return_value_policy::copy), + py::cpp_function(&MyClass::setData) + ); + +.. warning:: + + Code with invalid return value policies might access uninitialized memory or + free data structures multiple times, which can lead to hard-to-debug + non-determinism and segmentation faults, hence it is worth spending the + time to understand all the different options in the table above. + +.. note:: + + One important aspect of the above policies is that they only apply to + instances which pybind11 has *not* seen before, in which case the policy + clarifies essential questions about the return value's lifetime and + ownership. When pybind11 knows the instance already (as identified by its + type and address in memory), it will return the existing Python object + wrapper rather than creating a new copy. + +.. note:: + + The next section on :ref:`call_policies` discusses *call policies* that can be + specified *in addition* to a return value policy from the list above. Call + policies indicate reference relationships that can involve both return values + and parameters of functions. + +.. note:: + + As an alternative to elaborate call policies and lifetime management logic, + consider using smart pointers (see the section on :ref:`smart_pointers` for + details). Smart pointers can tell whether an object is still referenced from + C++ or Python, which generally eliminates the kinds of inconsistencies that + can lead to crashes or undefined behavior. For functions returning smart + pointers, it is not necessary to specify a return value policy. + +.. _call_policies: + +Additional call policies +======================== + +In addition to the above return value policies, further *call policies* can be +specified to indicate dependencies between parameters or ensure a certain state +for the function call. + +Keep alive +---------- + +In general, this policy is required when the C++ object is any kind of container +and another object is being added to the container. ``keep_alive`` +indicates that the argument with index ``Patient`` should be kept alive at least +until the argument with index ``Nurse`` is freed by the garbage collector. Argument +indices start at one, while zero refers to the return value. For methods, index +``1`` refers to the implicit ``this`` pointer, while regular arguments begin at +index ``2``. Arbitrarily many call policies can be specified. When a ``Nurse`` +with value ``None`` is detected at runtime, the call policy does nothing. + +When the nurse is not a pybind11-registered type, the implementation internally +relies on the ability to create a *weak reference* to the nurse object. When +the nurse object is not a pybind11-registered type and does not support weak +references, an exception will be thrown. + +If you use an incorrect argument index, you will get a ``RuntimeError`` saying +``Could not activate keep_alive!``. You should review the indices you're using. + +Consider the following example: here, the binding code for a list append +operation ties the lifetime of the newly added element to the underlying +container: + +.. code-block:: cpp + + py::class_(m, "List") + .def("append", &List::append, py::keep_alive<1, 2>()); + +For consistency, the argument indexing is identical for constructors. Index +``1`` still refers to the implicit ``this`` pointer, i.e. the object which is +being constructed. Index ``0`` refers to the return type which is presumed to +be ``void`` when a constructor is viewed like a function. The following example +ties the lifetime of the constructor element to the constructed object: + +.. code-block:: cpp + + py::class_(m, "Nurse") + .def(py::init(), py::keep_alive<1, 2>()); + +.. note:: + + ``keep_alive`` is analogous to the ``with_custodian_and_ward`` (if Nurse, + Patient != 0) and ``with_custodian_and_ward_postcall`` (if Nurse/Patient == + 0) policies from Boost.Python. + +Call guard +---------- + +The ``call_guard`` policy allows any scope guard type ``T`` to be placed +around the function call. For example, this definition: + +.. code-block:: cpp + + m.def("foo", foo, py::call_guard()); + +is equivalent to the following pseudocode: + +.. code-block:: cpp + + m.def("foo", [](args...) { + T scope_guard; + return foo(args...); // forwarded arguments + }); + +The only requirement is that ``T`` is default-constructible, but otherwise any +scope guard will work. This is very useful in combination with ``gil_scoped_release``. +See :ref:`gil`. + +Multiple guards can also be specified as ``py::call_guard``. The +constructor order is left to right and destruction happens in reverse. + +.. seealso:: + + The file :file:`tests/test_call_policies.cpp` contains a complete example + that demonstrates using `keep_alive` and `call_guard` in more detail. + +.. _python_objects_as_args: + +Python objects as arguments +=========================== + +pybind11 exposes all major Python types using thin C++ wrapper classes. These +wrapper classes can also be used as parameters of functions in bindings, which +makes it possible to directly work with native Python types on the C++ side. +For instance, the following statement iterates over a Python ``dict``: + +.. code-block:: cpp + + void print_dict(const py::dict& dict) { + /* Easily interact with Python types */ + for (auto item : dict) + std::cout << "key=" << std::string(py::str(item.first)) << ", " + << "value=" << std::string(py::str(item.second)) << std::endl; + } + +It can be exported: + +.. code-block:: cpp + + m.def("print_dict", &print_dict); + +And used in Python as usual: + +.. code-block:: pycon + + >>> print_dict({"foo": 123, "bar": "hello"}) + key=foo, value=123 + key=bar, value=hello + +For more information on using Python objects in C++, see :doc:`/advanced/pycpp/index`. + +Accepting \*args and \*\*kwargs +=============================== + +Python provides a useful mechanism to define functions that accept arbitrary +numbers of arguments and keyword arguments: + +.. code-block:: python + + def generic(*args, **kwargs): + ... # do something with args and kwargs + +Such functions can also be created using pybind11: + +.. code-block:: cpp + + void generic(py::args args, const py::kwargs& kwargs) { + /// .. do something with args + if (kwargs) + /// .. do something with kwargs + } + + /// Binding code + m.def("generic", &generic); + +The class ``py::args`` derives from ``py::tuple`` and ``py::kwargs`` derives +from ``py::dict``. + +You may also use just one or the other, and may combine these with other +arguments. Note, however, that ``py::kwargs`` must always be the last argument +of the function, and ``py::args`` implies that any further arguments are +keyword-only (see :ref:`keyword_only_arguments`). + +Please refer to the other examples for details on how to iterate over these, +and on how to cast their entries into C++ objects. A demonstration is also +available in ``tests/test_kwargs_and_defaults.cpp``. + +.. note:: + + When combining \*args or \*\*kwargs with :ref:`keyword_args` you should + *not* include ``py::arg`` tags for the ``py::args`` and ``py::kwargs`` + arguments. + +Default arguments revisited +=========================== + +The section on :ref:`default_args` previously discussed basic usage of default +arguments using pybind11. One noteworthy aspect of their implementation is that +default arguments are converted to Python objects right at declaration time. +Consider the following example: + +.. code-block:: cpp + + py::class_("MyClass") + .def("myFunction", py::arg("arg") = SomeType(123)); + +In this case, pybind11 must already be set up to deal with values of the type +``SomeType`` (via a prior instantiation of ``py::class_``), or an +exception will be thrown. + +Another aspect worth highlighting is that the "preview" of the default argument +in the function signature is generated using the object's ``__repr__`` method. +If not available, the signature may not be very helpful, e.g.: + +.. code-block:: pycon + + FUNCTIONS + ... + | myFunction(...) + | Signature : (MyClass, arg : SomeType = ) -> NoneType + ... + +The first way of addressing this is by defining ``SomeType.__repr__``. +Alternatively, it is possible to specify the human-readable preview of the +default argument manually using the ``arg_v`` notation: + +.. code-block:: cpp + + py::class_("MyClass") + .def("myFunction", py::arg_v("arg", SomeType(123), "SomeType(123)")); + +Sometimes it may be necessary to pass a null pointer value as a default +argument. In this case, remember to cast it to the underlying type in question, +like so: + +.. code-block:: cpp + + py::class_("MyClass") + .def("myFunction", py::arg("arg") = static_cast(nullptr)); + +.. _keyword_only_arguments: + +Keyword-only arguments +====================== + +Python implements keyword-only arguments by specifying an unnamed ``*`` +argument in a function definition: + +.. code-block:: python + + def f(a, *, b): # a can be positional or via keyword; b must be via keyword + pass + + + f(a=1, b=2) # good + f(b=2, a=1) # good + f(1, b=2) # good + f(1, 2) # TypeError: f() takes 1 positional argument but 2 were given + +Pybind11 provides a ``py::kw_only`` object that allows you to implement +the same behaviour by specifying the object between positional and keyword-only +argument annotations when registering the function: + +.. code-block:: cpp + + m.def("f", [](int a, int b) { /* ... */ }, + py::arg("a"), py::kw_only(), py::arg("b")); + +.. versionadded:: 2.6 + +A ``py::args`` argument implies that any following arguments are keyword-only, +as if ``py::kw_only()`` had been specified in the same relative location of the +argument list as the ``py::args`` argument. The ``py::kw_only()`` may be +included to be explicit about this, but is not required. + +.. versionchanged:: 2.9 + This can now be combined with ``py::args``. Before, ``py::args`` could only + occur at the end of the argument list, or immediately before a ``py::kwargs`` + argument at the end. + + +Positional-only arguments +========================= + +Python 3.8 introduced a new positional-only argument syntax, using ``/`` in the +function definition (note that this has been a convention for CPython +positional arguments, such as in ``pow()``, since Python 2). You can +do the same thing in any version of Python using ``py::pos_only()``: + +.. code-block:: cpp + + m.def("f", [](int a, int b) { /* ... */ }, + py::arg("a"), py::pos_only(), py::arg("b")); + +You now cannot give argument ``a`` by keyword. This can be combined with +keyword-only arguments, as well. + +.. versionadded:: 2.6 + +.. _nonconverting_arguments: + +Non-converting arguments +======================== + +Certain argument types may support conversion from one type to another. Some +examples of conversions are: + +* :ref:`implicit_conversions` declared using ``py::implicitly_convertible()`` +* Calling a method accepting a double with an integer argument +* Calling a ``std::complex`` argument with a non-complex python type + (for example, with a float). (Requires the optional ``pybind11/complex.h`` + header). +* Calling a function taking an Eigen matrix reference with a numpy array of the + wrong type or of an incompatible data layout. (Requires the optional + ``pybind11/eigen.h`` header). + +This behaviour is sometimes undesirable: the binding code may prefer to raise +an error rather than convert the argument. This behaviour can be obtained +through ``py::arg`` by calling the ``.noconvert()`` method of the ``py::arg`` +object, such as: + +.. code-block:: cpp + + m.def("floats_only", [](double f) { return 0.5 * f; }, py::arg("f").noconvert()); + m.def("floats_preferred", [](double f) { return 0.5 * f; }, py::arg("f")); + +Attempting the call the second function (the one without ``.noconvert()``) with +an integer will succeed, but attempting to call the ``.noconvert()`` version +will fail with a ``TypeError``: + +.. code-block:: pycon + + >>> floats_preferred(4) + 2.0 + >>> floats_only(4) + Traceback (most recent call last): + File "", line 1, in + TypeError: floats_only(): incompatible function arguments. The following argument types are supported: + 1. (f: float) -> float + + Invoked with: 4 + +You may, of course, combine this with the :var:`_a` shorthand notation (see +:ref:`keyword_args`) and/or :ref:`default_args`. It is also permitted to omit +the argument name by using the ``py::arg()`` constructor without an argument +name, i.e. by specifying ``py::arg().noconvert()``. + +.. note:: + + When specifying ``py::arg`` options it is necessary to provide the same + number of options as the bound function has arguments. Thus if you want to + enable no-convert behaviour for just one of several arguments, you will + need to specify a ``py::arg()`` annotation for each argument with the + no-convert argument modified to ``py::arg().noconvert()``. + +.. _none_arguments: + +Allow/Prohibiting None arguments +================================ + +When a C++ type registered with :class:`py::class_` is passed as an argument to +a function taking the instance as pointer or shared holder (e.g. ``shared_ptr`` +or a custom, copyable holder as described in :ref:`smart_pointers`), pybind +allows ``None`` to be passed from Python which results in calling the C++ +function with ``nullptr`` (or an empty holder) for the argument. + +To explicitly enable or disable this behaviour, using the +``.none`` method of the :class:`py::arg` object: + +.. code-block:: cpp + + py::class_(m, "Dog").def(py::init<>()); + py::class_(m, "Cat").def(py::init<>()); + m.def("bark", [](Dog *dog) -> std::string { + if (dog) return "woof!"; /* Called with a Dog instance */ + else return "(no dog)"; /* Called with None, dog == nullptr */ + }, py::arg("dog").none(true)); + m.def("meow", [](Cat *cat) -> std::string { + // Can't be called with None argument + return "meow"; + }, py::arg("cat").none(false)); + +With the above, the Python call ``bark(None)`` will return the string ``"(no +dog)"``, while attempting to call ``meow(None)`` will raise a ``TypeError``: + +.. code-block:: pycon + + >>> from animals import Dog, Cat, bark, meow + >>> bark(Dog()) + 'woof!' + >>> meow(Cat()) + 'meow' + >>> bark(None) + '(no dog)' + >>> meow(None) + Traceback (most recent call last): + File "", line 1, in + TypeError: meow(): incompatible function arguments. The following argument types are supported: + 1. (cat: animals.Cat) -> str + + Invoked with: None + +The default behaviour when the tag is unspecified is to allow ``None``. + +.. note:: + + Even when ``.none(true)`` is specified for an argument, ``None`` will be converted to a + ``nullptr`` *only* for custom and :ref:`opaque ` types. Pointers to built-in types + (``double *``, ``int *``, ...) and STL types (``std::vector *``, ...; if ``pybind11/stl.h`` + is included) are copied when converted to C++ (see :doc:`/advanced/cast/overview`) and will + not allow ``None`` as argument. To pass optional argument of these copied types consider + using ``std::optional`` + +.. _overload_resolution: + +Overload resolution order +========================= + +When a function or method with multiple overloads is called from Python, +pybind11 determines which overload to call in two passes. The first pass +attempts to call each overload without allowing argument conversion (as if +every argument had been specified as ``py::arg().noconvert()`` as described +above). + +If no overload succeeds in the no-conversion first pass, a second pass is +attempted in which argument conversion is allowed (except where prohibited via +an explicit ``py::arg().noconvert()`` attribute in the function definition). + +If the second pass also fails a ``TypeError`` is raised. + +Within each pass, overloads are tried in the order they were registered with +pybind11. If the ``py::prepend()`` tag is added to the definition, a function +can be placed at the beginning of the overload sequence instead, allowing user +overloads to proceed built in functions. + +What this means in practice is that pybind11 will prefer any overload that does +not require conversion of arguments to an overload that does, but otherwise +prefers earlier-defined overloads to later-defined ones. + +.. note:: + + pybind11 does *not* further prioritize based on the number/pattern of + overloaded arguments. That is, pybind11 does not prioritize a function + requiring one conversion over one requiring three, but only prioritizes + overloads requiring no conversion at all to overloads that require + conversion of at least one argument. + +.. versionadded:: 2.6 + + The ``py::prepend()`` tag. + +Binding functions with template parameters +========================================== + +You can bind functions that have template parameters. Here's a function: + +.. code-block:: cpp + + template + void set(T t); + +C++ templates cannot be instantiated at runtime, so you cannot bind the +non-instantiated function: + +.. code-block:: cpp + + // BROKEN (this will not compile) + m.def("set", &set); + +You must bind each instantiated function template separately. You may bind +each instantiation with the same name, which will be treated the same as +an overloaded function: + +.. code-block:: cpp + + m.def("set", &set); + m.def("set", &set); + +Sometimes it's more clear to bind them with separate names, which is also +an option: + +.. code-block:: cpp + + m.def("setInt", &set); + m.def("setString", &set); diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/misc.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/misc.rst new file mode 100644 index 000000000..805ec838f --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/misc.rst @@ -0,0 +1,400 @@ +Miscellaneous +############# + +.. _macro_notes: + +General notes regarding convenience macros +========================================== + +pybind11 provides a few convenience macros such as +:func:`PYBIND11_DECLARE_HOLDER_TYPE` and ``PYBIND11_OVERRIDE_*``. Since these +are "just" macros that are evaluated in the preprocessor (which has no concept +of types), they *will* get confused by commas in a template argument; for +example, consider: + +.. code-block:: cpp + + PYBIND11_OVERRIDE(MyReturnType, Class, func) + +The limitation of the C preprocessor interprets this as five arguments (with new +arguments beginning after each comma) rather than three. To get around this, +there are two alternatives: you can use a type alias, or you can wrap the type +using the ``PYBIND11_TYPE`` macro: + +.. code-block:: cpp + + // Version 1: using a type alias + using ReturnType = MyReturnType; + using ClassType = Class; + PYBIND11_OVERRIDE(ReturnType, ClassType, func); + + // Version 2: using the PYBIND11_TYPE macro: + PYBIND11_OVERRIDE(PYBIND11_TYPE(MyReturnType), + PYBIND11_TYPE(Class), func) + +The ``PYBIND11_MAKE_OPAQUE`` macro does *not* require the above workarounds. + +.. _gil: + +Global Interpreter Lock (GIL) +============================= + +The Python C API dictates that the Global Interpreter Lock (GIL) must always +be held by the current thread to safely access Python objects. As a result, +when Python calls into C++ via pybind11 the GIL must be held, and pybind11 +will never implicitly release the GIL. + +.. code-block:: cpp + + void my_function() { + /* GIL is held when this function is called from Python */ + } + + PYBIND11_MODULE(example, m) { + m.def("my_function", &my_function); + } + +pybind11 will ensure that the GIL is held when it knows that it is calling +Python code. For example, if a Python callback is passed to C++ code via +``std::function``, when C++ code calls the function the built-in wrapper +will acquire the GIL before calling the Python callback. Similarly, the +``PYBIND11_OVERRIDE`` family of macros will acquire the GIL before calling +back into Python. + +When writing C++ code that is called from other C++ code, if that code accesses +Python state, it must explicitly acquire and release the GIL. + +The classes :class:`gil_scoped_release` and :class:`gil_scoped_acquire` can be +used to acquire and release the global interpreter lock in the body of a C++ +function call. In this way, long-running C++ code can be parallelized using +multiple Python threads, **but great care must be taken** when any +:class:`gil_scoped_release` appear: if there is any way that the C++ code +can access Python objects, :class:`gil_scoped_acquire` should be used to +reacquire the GIL. Taking :ref:`overriding_virtuals` as an example, this +could be realized as follows (important changes highlighted): + +.. code-block:: cpp + :emphasize-lines: 8,30,31 + + class PyAnimal : public Animal { + public: + /* Inherit the constructors */ + using Animal::Animal; + + /* Trampoline (need one for each virtual function) */ + std::string go(int n_times) { + /* PYBIND11_OVERRIDE_PURE will acquire the GIL before accessing Python state */ + PYBIND11_OVERRIDE_PURE( + std::string, /* Return type */ + Animal, /* Parent class */ + go, /* Name of function */ + n_times /* Argument(s) */ + ); + } + }; + + PYBIND11_MODULE(example, m) { + py::class_ animal(m, "Animal"); + animal + .def(py::init<>()) + .def("go", &Animal::go); + + py::class_(m, "Dog", animal) + .def(py::init<>()); + + m.def("call_go", [](Animal *animal) -> std::string { + // GIL is held when called from Python code. Release GIL before + // calling into (potentially long-running) C++ code + py::gil_scoped_release release; + return call_go(animal); + }); + } + +The ``call_go`` wrapper can also be simplified using the ``call_guard`` policy +(see :ref:`call_policies`) which yields the same result: + +.. code-block:: cpp + + m.def("call_go", &call_go, py::call_guard()); + + +Common Sources Of Global Interpreter Lock Errors +================================================================== + +Failing to properly hold the Global Interpreter Lock (GIL) is one of the +more common sources of bugs within code that uses pybind11. If you are +running into GIL related errors, we highly recommend you consult the +following checklist. + +- Do you have any global variables that are pybind11 objects or invoke + pybind11 functions in either their constructor or destructor? You are generally + not allowed to invoke any Python function in a global static context. We recommend + using lazy initialization and then intentionally leaking at the end of the program. + +- Do you have any pybind11 objects that are members of other C++ structures? One + commonly overlooked requirement is that pybind11 objects have to increase their reference count + whenever their copy constructor is called. Thus, you need to be holding the GIL to invoke + the copy constructor of any C++ class that has a pybind11 member. This can sometimes be very + tricky to track for complicated programs Think carefully when you make a pybind11 object + a member in another struct. + +- C++ destructors that invoke Python functions can be particularly troublesome as + destructors can sometimes get invoked in weird and unexpected circumstances as a result + of exceptions. + +- You should try running your code in a debug build. That will enable additional assertions + within pybind11 that will throw exceptions on certain GIL handling errors + (reference counting operations). + +Binding sequence data types, iterators, the slicing protocol, etc. +================================================================== + +Please refer to the supplemental example for details. + +.. seealso:: + + The file :file:`tests/test_sequences_and_iterators.cpp` contains a + complete example that shows how to bind a sequence data type, including + length queries (``__len__``), iterators (``__iter__``), the slicing + protocol and other kinds of useful operations. + + +Partitioning code over multiple extension modules +================================================= + +It's straightforward to split binding code over multiple extension modules, +while referencing types that are declared elsewhere. Everything "just" works +without any special precautions. One exception to this rule occurs when +extending a type declared in another extension module. Recall the basic example +from Section :ref:`inheritance`. + +.. code-block:: cpp + + py::class_ pet(m, "Pet"); + pet.def(py::init()) + .def_readwrite("name", &Pet::name); + + py::class_(m, "Dog", pet /* <- specify parent */) + .def(py::init()) + .def("bark", &Dog::bark); + +Suppose now that ``Pet`` bindings are defined in a module named ``basic``, +whereas the ``Dog`` bindings are defined somewhere else. The challenge is of +course that the variable ``pet`` is not available anymore though it is needed +to indicate the inheritance relationship to the constructor of ``class_``. +However, it can be acquired as follows: + +.. code-block:: cpp + + py::object pet = (py::object) py::module_::import("basic").attr("Pet"); + + py::class_(m, "Dog", pet) + .def(py::init()) + .def("bark", &Dog::bark); + +Alternatively, you can specify the base class as a template parameter option to +``class_``, which performs an automated lookup of the corresponding Python +type. Like the above code, however, this also requires invoking the ``import`` +function once to ensure that the pybind11 binding code of the module ``basic`` +has been executed: + +.. code-block:: cpp + + py::module_::import("basic"); + + py::class_(m, "Dog") + .def(py::init()) + .def("bark", &Dog::bark); + +Naturally, both methods will fail when there are cyclic dependencies. + +Note that pybind11 code compiled with hidden-by-default symbol visibility (e.g. +via the command line flag ``-fvisibility=hidden`` on GCC/Clang), which is +required for proper pybind11 functionality, can interfere with the ability to +access types defined in another extension module. Working around this requires +manually exporting types that are accessed by multiple extension modules; +pybind11 provides a macro to do just this: + +.. code-block:: cpp + + class PYBIND11_EXPORT Dog : public Animal { + ... + }; + +Note also that it is possible (although would rarely be required) to share arbitrary +C++ objects between extension modules at runtime. Internal library data is shared +between modules using capsule machinery [#f6]_ which can be also utilized for +storing, modifying and accessing user-defined data. Note that an extension module +will "see" other extensions' data if and only if they were built with the same +pybind11 version. Consider the following example: + +.. code-block:: cpp + + auto data = reinterpret_cast(py::get_shared_data("mydata")); + if (!data) + data = static_cast(py::set_shared_data("mydata", new MyData(42))); + +If the above snippet was used in several separately compiled extension modules, +the first one to be imported would create a ``MyData`` instance and associate +a ``"mydata"`` key with a pointer to it. Extensions that are imported later +would be then able to access the data behind the same pointer. + +.. [#f6] https://docs.python.org/3/extending/extending.html#using-capsules + +Module Destructors +================== + +pybind11 does not provide an explicit mechanism to invoke cleanup code at +module destruction time. In rare cases where such functionality is required, it +is possible to emulate it using Python capsules or weak references with a +destruction callback. + +.. code-block:: cpp + + auto cleanup_callback = []() { + // perform cleanup here -- this function is called with the GIL held + }; + + m.add_object("_cleanup", py::capsule(cleanup_callback)); + +This approach has the potential downside that instances of classes exposed +within the module may still be alive when the cleanup callback is invoked +(whether this is acceptable will generally depend on the application). + +Alternatively, the capsule may also be stashed within a type object, which +ensures that it not called before all instances of that type have been +collected: + +.. code-block:: cpp + + auto cleanup_callback = []() { /* ... */ }; + m.attr("BaseClass").attr("_cleanup") = py::capsule(cleanup_callback); + +Both approaches also expose a potentially dangerous ``_cleanup`` attribute in +Python, which may be undesirable from an API standpoint (a premature explicit +call from Python might lead to undefined behavior). Yet another approach that +avoids this issue involves weak reference with a cleanup callback: + +.. code-block:: cpp + + // Register a callback function that is invoked when the BaseClass object is collected + py::cpp_function cleanup_callback( + [](py::handle weakref) { + // perform cleanup here -- this function is called with the GIL held + + weakref.dec_ref(); // release weak reference + } + ); + + // Create a weak reference with a cleanup callback and initially leak it + (void) py::weakref(m.attr("BaseClass"), cleanup_callback).release(); + +.. note:: + + PyPy does not garbage collect objects when the interpreter exits. An alternative + approach (which also works on CPython) is to use the :py:mod:`atexit` module [#f7]_, + for example: + + .. code-block:: cpp + + auto atexit = py::module_::import("atexit"); + atexit.attr("register")(py::cpp_function([]() { + // perform cleanup here -- this function is called with the GIL held + })); + + .. [#f7] https://docs.python.org/3/library/atexit.html + + +Generating documentation using Sphinx +===================================== + +Sphinx [#f4]_ has the ability to inspect the signatures and documentation +strings in pybind11-based extension modules to automatically generate beautiful +documentation in a variety formats. The python_example repository [#f5]_ contains a +simple example repository which uses this approach. + +There are two potential gotchas when using this approach: first, make sure that +the resulting strings do not contain any :kbd:`TAB` characters, which break the +docstring parsing routines. You may want to use C++11 raw string literals, +which are convenient for multi-line comments. Conveniently, any excess +indentation will be automatically be removed by Sphinx. However, for this to +work, it is important that all lines are indented consistently, i.e.: + +.. code-block:: cpp + + // ok + m.def("foo", &foo, R"mydelimiter( + The foo function + + Parameters + ---------- + )mydelimiter"); + + // *not ok* + m.def("foo", &foo, R"mydelimiter(The foo function + + Parameters + ---------- + )mydelimiter"); + +By default, pybind11 automatically generates and prepends a signature to the docstring of a function +registered with ``module_::def()`` and ``class_::def()``. Sometimes this +behavior is not desirable, because you want to provide your own signature or remove +the docstring completely to exclude the function from the Sphinx documentation. +The class ``options`` allows you to selectively suppress auto-generated signatures: + +.. code-block:: cpp + + PYBIND11_MODULE(example, m) { + py::options options; + options.disable_function_signatures(); + + m.def("add", [](int a, int b) { return a + b; }, "A function which adds two numbers"); + } + +pybind11 also appends all members of an enum to the resulting enum docstring. +This default behavior can be disabled by using the ``disable_enum_members_docstring()`` +function of the ``options`` class. + +With ``disable_user_defined_docstrings()`` all user defined docstrings of +``module_::def()``, ``class_::def()`` and ``enum_()`` are disabled, but the +function signatures and enum members are included in the docstring, unless they +are disabled separately. + +Note that changes to the settings affect only function bindings created during the +lifetime of the ``options`` instance. When it goes out of scope at the end of the module's init function, +the default settings are restored to prevent unwanted side effects. + +.. [#f4] http://www.sphinx-doc.org +.. [#f5] http://github.com/pybind/python_example + +.. _avoiding-cpp-types-in-docstrings: + +Avoiding C++ types in docstrings +================================ + +Docstrings are generated at the time of the declaration, e.g. when ``.def(...)`` is called. +At this point parameter and return types should be known to pybind11. +If a custom type is not exposed yet through a ``py::class_`` constructor or a custom type caster, +its C++ type name will be used instead to generate the signature in the docstring: + +.. code-block:: text + + | __init__(...) + | __init__(self: example.Foo, arg0: ns::Bar) -> None + ^^^^^^^ + + +This limitation can be circumvented by ensuring that C++ classes are registered with pybind11 +before they are used as a parameter or return type of a function: + +.. code-block:: cpp + + PYBIND11_MODULE(example, m) { + + auto pyFoo = py::class_(m, "Foo"); + auto pyBar = py::class_(m, "Bar"); + + pyFoo.def(py::init()); + pyBar.def(py::init()); + } diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/pycpp/index.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/pycpp/index.rst new file mode 100644 index 000000000..6885bdcff --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/pycpp/index.rst @@ -0,0 +1,13 @@ +Python C++ interface +#################### + +pybind11 exposes Python types and functions using thin C++ wrappers, which +makes it possible to conveniently call Python code from C++ without resorting +to Python's C API. + +.. toctree:: + :maxdepth: 2 + + object + numpy + utilities diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/pycpp/numpy.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/pycpp/numpy.rst new file mode 100644 index 000000000..07c969305 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/pycpp/numpy.rst @@ -0,0 +1,455 @@ +.. _numpy: + +NumPy +##### + +Buffer protocol +=============== + +Python supports an extremely general and convenient approach for exchanging +data between plugin libraries. Types can expose a buffer view [#f2]_, which +provides fast direct access to the raw internal data representation. Suppose we +want to bind the following simplistic Matrix class: + +.. code-block:: cpp + + class Matrix { + public: + Matrix(size_t rows, size_t cols) : m_rows(rows), m_cols(cols) { + m_data = new float[rows*cols]; + } + float *data() { return m_data; } + size_t rows() const { return m_rows; } + size_t cols() const { return m_cols; } + private: + size_t m_rows, m_cols; + float *m_data; + }; + +The following binding code exposes the ``Matrix`` contents as a buffer object, +making it possible to cast Matrices into NumPy arrays. It is even possible to +completely avoid copy operations with Python expressions like +``np.array(matrix_instance, copy = False)``. + +.. code-block:: cpp + + py::class_(m, "Matrix", py::buffer_protocol()) + .def_buffer([](Matrix &m) -> py::buffer_info { + return py::buffer_info( + m.data(), /* Pointer to buffer */ + sizeof(float), /* Size of one scalar */ + py::format_descriptor::format(), /* Python struct-style format descriptor */ + 2, /* Number of dimensions */ + { m.rows(), m.cols() }, /* Buffer dimensions */ + { sizeof(float) * m.cols(), /* Strides (in bytes) for each index */ + sizeof(float) } + ); + }); + +Supporting the buffer protocol in a new type involves specifying the special +``py::buffer_protocol()`` tag in the ``py::class_`` constructor and calling the +``def_buffer()`` method with a lambda function that creates a +``py::buffer_info`` description record on demand describing a given matrix +instance. The contents of ``py::buffer_info`` mirror the Python buffer protocol +specification. + +.. code-block:: cpp + + struct buffer_info { + void *ptr; + py::ssize_t itemsize; + std::string format; + py::ssize_t ndim; + std::vector shape; + std::vector strides; + }; + +To create a C++ function that can take a Python buffer object as an argument, +simply use the type ``py::buffer`` as one of its arguments. Buffers can exist +in a great variety of configurations, hence some safety checks are usually +necessary in the function body. Below, you can see a basic example on how to +define a custom constructor for the Eigen double precision matrix +(``Eigen::MatrixXd``) type, which supports initialization from compatible +buffer objects (e.g. a NumPy matrix). + +.. code-block:: cpp + + /* Bind MatrixXd (or some other Eigen type) to Python */ + typedef Eigen::MatrixXd Matrix; + + typedef Matrix::Scalar Scalar; + constexpr bool rowMajor = Matrix::Flags & Eigen::RowMajorBit; + + py::class_(m, "Matrix", py::buffer_protocol()) + .def(py::init([](py::buffer b) { + typedef Eigen::Stride Strides; + + /* Request a buffer descriptor from Python */ + py::buffer_info info = b.request(); + + /* Some basic validation checks ... */ + if (info.format != py::format_descriptor::format()) + throw std::runtime_error("Incompatible format: expected a double array!"); + + if (info.ndim != 2) + throw std::runtime_error("Incompatible buffer dimension!"); + + auto strides = Strides( + info.strides[rowMajor ? 0 : 1] / (py::ssize_t)sizeof(Scalar), + info.strides[rowMajor ? 1 : 0] / (py::ssize_t)sizeof(Scalar)); + + auto map = Eigen::Map( + static_cast(info.ptr), info.shape[0], info.shape[1], strides); + + return Matrix(map); + })); + +For reference, the ``def_buffer()`` call for this Eigen data type should look +as follows: + +.. code-block:: cpp + + .def_buffer([](Matrix &m) -> py::buffer_info { + return py::buffer_info( + m.data(), /* Pointer to buffer */ + sizeof(Scalar), /* Size of one scalar */ + py::format_descriptor::format(), /* Python struct-style format descriptor */ + 2, /* Number of dimensions */ + { m.rows(), m.cols() }, /* Buffer dimensions */ + { sizeof(Scalar) * (rowMajor ? m.cols() : 1), + sizeof(Scalar) * (rowMajor ? 1 : m.rows()) } + /* Strides (in bytes) for each index */ + ); + }) + +For a much easier approach of binding Eigen types (although with some +limitations), refer to the section on :doc:`/advanced/cast/eigen`. + +.. seealso:: + + The file :file:`tests/test_buffers.cpp` contains a complete example + that demonstrates using the buffer protocol with pybind11 in more detail. + +.. [#f2] http://docs.python.org/3/c-api/buffer.html + +Arrays +====== + +By exchanging ``py::buffer`` with ``py::array`` in the above snippet, we can +restrict the function so that it only accepts NumPy arrays (rather than any +type of Python object satisfying the buffer protocol). + +In many situations, we want to define a function which only accepts a NumPy +array of a certain data type. This is possible via the ``py::array_t`` +template. For instance, the following function requires the argument to be a +NumPy array containing double precision values. + +.. code-block:: cpp + + void f(py::array_t array); + +When it is invoked with a different type (e.g. an integer or a list of +integers), the binding code will attempt to cast the input into a NumPy array +of the requested type. This feature requires the :file:`pybind11/numpy.h` +header to be included. Note that :file:`pybind11/numpy.h` does not depend on +the NumPy headers, and thus can be used without declaring a build-time +dependency on NumPy; NumPy>=1.7.0 is a runtime dependency. + +Data in NumPy arrays is not guaranteed to packed in a dense manner; +furthermore, entries can be separated by arbitrary column and row strides. +Sometimes, it can be useful to require a function to only accept dense arrays +using either the C (row-major) or Fortran (column-major) ordering. This can be +accomplished via a second template argument with values ``py::array::c_style`` +or ``py::array::f_style``. + +.. code-block:: cpp + + void f(py::array_t array); + +The ``py::array::forcecast`` argument is the default value of the second +template parameter, and it ensures that non-conforming arguments are converted +into an array satisfying the specified requirements instead of trying the next +function overload. + +There are several methods on arrays; the methods listed below under references +work, as well as the following functions based on the NumPy API: + +- ``.dtype()`` returns the type of the contained values. + +- ``.strides()`` returns a pointer to the strides of the array (optionally pass + an integer axis to get a number). + +- ``.flags()`` returns the flag settings. ``.writable()`` and ``.owndata()`` + are directly available. + +- ``.offset_at()`` returns the offset (optionally pass indices). + +- ``.squeeze()`` returns a view with length-1 axes removed. + +- ``.view(dtype)`` returns a view of the array with a different dtype. + +- ``.reshape({i, j, ...})`` returns a view of the array with a different shape. + ``.resize({...})`` is also available. + +- ``.index_at(i, j, ...)`` gets the count from the beginning to a given index. + + +There are also several methods for getting references (described below). + +Structured types +================ + +In order for ``py::array_t`` to work with structured (record) types, we first +need to register the memory layout of the type. This can be done via +``PYBIND11_NUMPY_DTYPE`` macro, called in the plugin definition code, which +expects the type followed by field names: + +.. code-block:: cpp + + struct A { + int x; + double y; + }; + + struct B { + int z; + A a; + }; + + // ... + PYBIND11_MODULE(test, m) { + // ... + + PYBIND11_NUMPY_DTYPE(A, x, y); + PYBIND11_NUMPY_DTYPE(B, z, a); + /* now both A and B can be used as template arguments to py::array_t */ + } + +The structure should consist of fundamental arithmetic types, ``std::complex``, +previously registered substructures, and arrays of any of the above. Both C++ +arrays and ``std::array`` are supported. While there is a static assertion to +prevent many types of unsupported structures, it is still the user's +responsibility to use only "plain" structures that can be safely manipulated as +raw memory without violating invariants. + +Vectorizing functions +===================== + +Suppose we want to bind a function with the following signature to Python so +that it can process arbitrary NumPy array arguments (vectors, matrices, general +N-D arrays) in addition to its normal arguments: + +.. code-block:: cpp + + double my_func(int x, float y, double z); + +After including the ``pybind11/numpy.h`` header, this is extremely simple: + +.. code-block:: cpp + + m.def("vectorized_func", py::vectorize(my_func)); + +Invoking the function like below causes 4 calls to be made to ``my_func`` with +each of the array elements. The significant advantage of this compared to +solutions like ``numpy.vectorize()`` is that the loop over the elements runs +entirely on the C++ side and can be crunched down into a tight, optimized loop +by the compiler. The result is returned as a NumPy array of type +``numpy.dtype.float64``. + +.. code-block:: pycon + + >>> x = np.array([[1, 3], [5, 7]]) + >>> y = np.array([[2, 4], [6, 8]]) + >>> z = 3 + >>> result = vectorized_func(x, y, z) + +The scalar argument ``z`` is transparently replicated 4 times. The input +arrays ``x`` and ``y`` are automatically converted into the right types (they +are of type ``numpy.dtype.int64`` but need to be ``numpy.dtype.int32`` and +``numpy.dtype.float32``, respectively). + +.. note:: + + Only arithmetic, complex, and POD types passed by value or by ``const &`` + reference are vectorized; all other arguments are passed through as-is. + Functions taking rvalue reference arguments cannot be vectorized. + +In cases where the computation is too complicated to be reduced to +``vectorize``, it will be necessary to create and access the buffer contents +manually. The following snippet contains a complete example that shows how this +works (the code is somewhat contrived, since it could have been done more +simply using ``vectorize``). + +.. code-block:: cpp + + #include + #include + + namespace py = pybind11; + + py::array_t add_arrays(py::array_t input1, py::array_t input2) { + py::buffer_info buf1 = input1.request(), buf2 = input2.request(); + + if (buf1.ndim != 1 || buf2.ndim != 1) + throw std::runtime_error("Number of dimensions must be one"); + + if (buf1.size != buf2.size) + throw std::runtime_error("Input shapes must match"); + + /* No pointer is passed, so NumPy will allocate the buffer */ + auto result = py::array_t(buf1.size); + + py::buffer_info buf3 = result.request(); + + double *ptr1 = static_cast(buf1.ptr); + double *ptr2 = static_cast(buf2.ptr); + double *ptr3 = static_cast(buf3.ptr); + + for (size_t idx = 0; idx < buf1.shape[0]; idx++) + ptr3[idx] = ptr1[idx] + ptr2[idx]; + + return result; + } + + PYBIND11_MODULE(test, m) { + m.def("add_arrays", &add_arrays, "Add two NumPy arrays"); + } + +.. seealso:: + + The file :file:`tests/test_numpy_vectorize.cpp` contains a complete + example that demonstrates using :func:`vectorize` in more detail. + +Direct access +============= + +For performance reasons, particularly when dealing with very large arrays, it +is often desirable to directly access array elements without internal checking +of dimensions and bounds on every access when indices are known to be already +valid. To avoid such checks, the ``array`` class and ``array_t`` template +class offer an unchecked proxy object that can be used for this unchecked +access through the ``unchecked`` and ``mutable_unchecked`` methods, +where ``N`` gives the required dimensionality of the array: + +.. code-block:: cpp + + m.def("sum_3d", [](py::array_t x) { + auto r = x.unchecked<3>(); // x must have ndim = 3; can be non-writeable + double sum = 0; + for (py::ssize_t i = 0; i < r.shape(0); i++) + for (py::ssize_t j = 0; j < r.shape(1); j++) + for (py::ssize_t k = 0; k < r.shape(2); k++) + sum += r(i, j, k); + return sum; + }); + m.def("increment_3d", [](py::array_t x) { + auto r = x.mutable_unchecked<3>(); // Will throw if ndim != 3 or flags.writeable is false + for (py::ssize_t i = 0; i < r.shape(0); i++) + for (py::ssize_t j = 0; j < r.shape(1); j++) + for (py::ssize_t k = 0; k < r.shape(2); k++) + r(i, j, k) += 1.0; + }, py::arg().noconvert()); + +To obtain the proxy from an ``array`` object, you must specify both the data +type and number of dimensions as template arguments, such as ``auto r = +myarray.mutable_unchecked()``. + +If the number of dimensions is not known at compile time, you can omit the +dimensions template parameter (i.e. calling ``arr_t.unchecked()`` or +``arr.unchecked()``. This will give you a proxy object that works in the +same way, but results in less optimizable code and thus a small efficiency +loss in tight loops. + +Note that the returned proxy object directly references the array's data, and +only reads its shape, strides, and writeable flag when constructed. You must +take care to ensure that the referenced array is not destroyed or reshaped for +the duration of the returned object, typically by limiting the scope of the +returned instance. + +The returned proxy object supports some of the same methods as ``py::array`` so +that it can be used as a drop-in replacement for some existing, index-checked +uses of ``py::array``: + +- ``.ndim()`` returns the number of dimensions + +- ``.data(1, 2, ...)`` and ``r.mutable_data(1, 2, ...)``` returns a pointer to + the ``const T`` or ``T`` data, respectively, at the given indices. The + latter is only available to proxies obtained via ``a.mutable_unchecked()``. + +- ``.itemsize()`` returns the size of an item in bytes, i.e. ``sizeof(T)``. + +- ``.ndim()`` returns the number of dimensions. + +- ``.shape(n)`` returns the size of dimension ``n`` + +- ``.size()`` returns the total number of elements (i.e. the product of the shapes). + +- ``.nbytes()`` returns the number of bytes used by the referenced elements + (i.e. ``itemsize()`` times ``size()``). + +.. seealso:: + + The file :file:`tests/test_numpy_array.cpp` contains additional examples + demonstrating the use of this feature. + +Ellipsis +======== + +Python provides a convenient ``...`` ellipsis notation that is often used to +slice multidimensional arrays. For instance, the following snippet extracts the +middle dimensions of a tensor with the first and last index set to zero. + +.. code-block:: python + + a = ... # a NumPy array + b = a[0, ..., 0] + +The function ``py::ellipsis()`` function can be used to perform the same +operation on the C++ side: + +.. code-block:: cpp + + py::array a = /* A NumPy array */; + py::array b = a[py::make_tuple(0, py::ellipsis(), 0)]; + + +Memory view +=========== + +For a case when we simply want to provide a direct accessor to C/C++ buffer +without a concrete class object, we can return a ``memoryview`` object. Suppose +we wish to expose a ``memoryview`` for 2x4 uint8_t array, we can do the +following: + +.. code-block:: cpp + + const uint8_t buffer[] = { + 0, 1, 2, 3, + 4, 5, 6, 7 + }; + m.def("get_memoryview2d", []() { + return py::memoryview::from_buffer( + buffer, // buffer pointer + { 2, 4 }, // shape (rows, cols) + { sizeof(uint8_t) * 4, sizeof(uint8_t) } // strides in bytes + ); + }); + +This approach is meant for providing a ``memoryview`` for a C/C++ buffer not +managed by Python. The user is responsible for managing the lifetime of the +buffer. Using a ``memoryview`` created in this way after deleting the buffer in +C++ side results in undefined behavior. + +We can also use ``memoryview::from_memory`` for a simple 1D contiguous buffer: + +.. code-block:: cpp + + m.def("get_memoryview1d", []() { + return py::memoryview::from_memory( + buffer, // buffer pointer + sizeof(uint8_t) * 8 // buffer size + ); + }); + +.. versionchanged:: 2.6 + ``memoryview::from_memory`` added. diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/pycpp/object.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/pycpp/object.rst new file mode 100644 index 000000000..93e1a94d8 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/pycpp/object.rst @@ -0,0 +1,286 @@ +Python types +############ + +.. _wrappers: + +Available wrappers +================== + +All major Python types are available as thin C++ wrapper classes. These +can also be used as function parameters -- see :ref:`python_objects_as_args`. + +Available types include :class:`handle`, :class:`object`, :class:`bool_`, +:class:`int_`, :class:`float_`, :class:`str`, :class:`bytes`, :class:`tuple`, +:class:`list`, :class:`dict`, :class:`slice`, :class:`none`, :class:`capsule`, +:class:`iterable`, :class:`iterator`, :class:`function`, :class:`buffer`, +:class:`array`, and :class:`array_t`. + +.. warning:: + + Be sure to review the :ref:`pytypes_gotchas` before using this heavily in + your C++ API. + +.. _instantiating_compound_types: + +Instantiating compound Python types from C++ +============================================ + +Dictionaries can be initialized in the :class:`dict` constructor: + +.. code-block:: cpp + + using namespace pybind11::literals; // to bring in the `_a` literal + py::dict d("spam"_a=py::none(), "eggs"_a=42); + +A tuple of python objects can be instantiated using :func:`py::make_tuple`: + +.. code-block:: cpp + + py::tuple tup = py::make_tuple(42, py::none(), "spam"); + +Each element is converted to a supported Python type. + +A `simple namespace`_ can be instantiated using + +.. code-block:: cpp + + using namespace pybind11::literals; // to bring in the `_a` literal + py::object SimpleNamespace = py::module_::import("types").attr("SimpleNamespace"); + py::object ns = SimpleNamespace("spam"_a=py::none(), "eggs"_a=42); + +Attributes on a namespace can be modified with the :func:`py::delattr`, +:func:`py::getattr`, and :func:`py::setattr` functions. Simple namespaces can +be useful as lightweight stand-ins for class instances. + +.. _simple namespace: https://docs.python.org/3/library/types.html#types.SimpleNamespace + +.. _casting_back_and_forth: + +Casting back and forth +====================== + +In this kind of mixed code, it is often necessary to convert arbitrary C++ +types to Python, which can be done using :func:`py::cast`: + +.. code-block:: cpp + + MyClass *cls = ...; + py::object obj = py::cast(cls); + +The reverse direction uses the following syntax: + +.. code-block:: cpp + + py::object obj = ...; + MyClass *cls = obj.cast(); + +When conversion fails, both directions throw the exception :class:`cast_error`. + +.. _python_libs: + +Accessing Python libraries from C++ +=================================== + +It is also possible to import objects defined in the Python standard +library or available in the current Python environment (``sys.path``) and work +with these in C++. + +This example obtains a reference to the Python ``Decimal`` class. + +.. code-block:: cpp + + // Equivalent to "from decimal import Decimal" + py::object Decimal = py::module_::import("decimal").attr("Decimal"); + +.. code-block:: cpp + + // Try to import scipy + py::object scipy = py::module_::import("scipy"); + return scipy.attr("__version__"); + + +.. _calling_python_functions: + +Calling Python functions +======================== + +It is also possible to call Python classes, functions and methods +via ``operator()``. + +.. code-block:: cpp + + // Construct a Python object of class Decimal + py::object pi = Decimal("3.14159"); + +.. code-block:: cpp + + // Use Python to make our directories + py::object os = py::module_::import("os"); + py::object makedirs = os.attr("makedirs"); + makedirs("/tmp/path/to/somewhere"); + +One can convert the result obtained from Python to a pure C++ version +if a ``py::class_`` or type conversion is defined. + +.. code-block:: cpp + + py::function f = <...>; + py::object result_py = f(1234, "hello", some_instance); + MyClass &result = result_py.cast(); + +.. _calling_python_methods: + +Calling Python methods +======================== + +To call an object's method, one can again use ``.attr`` to obtain access to the +Python method. + +.. code-block:: cpp + + // Calculate e^π in decimal + py::object exp_pi = pi.attr("exp")(); + py::print(py::str(exp_pi)); + +In the example above ``pi.attr("exp")`` is a *bound method*: it will always call +the method for that same instance of the class. Alternately one can create an +*unbound method* via the Python class (instead of instance) and pass the ``self`` +object explicitly, followed by other arguments. + +.. code-block:: cpp + + py::object decimal_exp = Decimal.attr("exp"); + + // Compute the e^n for n=0..4 + for (int n = 0; n < 5; n++) { + py::print(decimal_exp(Decimal(n)); + } + +Keyword arguments +================= + +Keyword arguments are also supported. In Python, there is the usual call syntax: + +.. code-block:: python + + def f(number, say, to): + ... # function code + + + f(1234, say="hello", to=some_instance) # keyword call in Python + +In C++, the same call can be made using: + +.. code-block:: cpp + + using namespace pybind11::literals; // to bring in the `_a` literal + f(1234, "say"_a="hello", "to"_a=some_instance); // keyword call in C++ + +Unpacking arguments +=================== + +Unpacking of ``*args`` and ``**kwargs`` is also possible and can be mixed with +other arguments: + +.. code-block:: cpp + + // * unpacking + py::tuple args = py::make_tuple(1234, "hello", some_instance); + f(*args); + + // ** unpacking + py::dict kwargs = py::dict("number"_a=1234, "say"_a="hello", "to"_a=some_instance); + f(**kwargs); + + // mixed keywords, * and ** unpacking + py::tuple args = py::make_tuple(1234); + py::dict kwargs = py::dict("to"_a=some_instance); + f(*args, "say"_a="hello", **kwargs); + +Generalized unpacking according to PEP448_ is also supported: + +.. code-block:: cpp + + py::dict kwargs1 = py::dict("number"_a=1234); + py::dict kwargs2 = py::dict("to"_a=some_instance); + f(**kwargs1, "say"_a="hello", **kwargs2); + +.. seealso:: + + The file :file:`tests/test_pytypes.cpp` contains a complete + example that demonstrates passing native Python types in more detail. The + file :file:`tests/test_callbacks.cpp` presents a few examples of calling + Python functions from C++, including keywords arguments and unpacking. + +.. _PEP448: https://www.python.org/dev/peps/pep-0448/ + +.. _implicit_casting: + +Implicit casting +================ + +When using the C++ interface for Python types, or calling Python functions, +objects of type :class:`object` are returned. It is possible to invoke implicit +conversions to subclasses like :class:`dict`. The same holds for the proxy objects +returned by ``operator[]`` or ``obj.attr()``. +Casting to subtypes improves code readability and allows values to be passed to +C++ functions that require a specific subtype rather than a generic :class:`object`. + +.. code-block:: cpp + + #include + using namespace pybind11::literals; + + py::module_ os = py::module_::import("os"); + py::module_ path = py::module_::import("os.path"); // like 'import os.path as path' + py::module_ np = py::module_::import("numpy"); // like 'import numpy as np' + + py::str curdir_abs = path.attr("abspath")(path.attr("curdir")); + py::print(py::str("Current directory: ") + curdir_abs); + py::dict environ = os.attr("environ"); + py::print(environ["HOME"]); + py::array_t arr = np.attr("ones")(3, "dtype"_a="float32"); + py::print(py::repr(arr + py::int_(1))); + +These implicit conversions are available for subclasses of :class:`object`; there +is no need to call ``obj.cast()`` explicitly as for custom classes, see +:ref:`casting_back_and_forth`. + +.. note:: + If a trivial conversion via move constructor is not possible, both implicit and + explicit casting (calling ``obj.cast()``) will attempt a "rich" conversion. + For instance, ``py::list env = os.attr("environ");`` will succeed and is + equivalent to the Python code ``env = list(os.environ)`` that produces a + list of the dict keys. + +.. TODO: Adapt text once PR #2349 has landed + +Handling exceptions +=================== + +Python exceptions from wrapper classes will be thrown as a ``py::error_already_set``. +See :ref:`Handling exceptions from Python in C++ +` for more information on handling exceptions +raised when calling C++ wrapper classes. + +.. _pytypes_gotchas: + +Gotchas +======= + +Default-Constructed Wrappers +---------------------------- + +When a wrapper type is default-constructed, it is **not** a valid Python object (i.e. it is not ``py::none()``). It is simply the same as +``PyObject*`` null pointer. To check for this, use +``static_cast(my_wrapper)``. + +Assigning py::none() to wrappers +-------------------------------- + +You may be tempted to use types like ``py::str`` and ``py::dict`` in C++ +signatures (either pure C++, or in bound signatures), and assign them default +values of ``py::none()``. However, in a best case scenario, it will fail fast +because ``None`` is not convertible to that type (e.g. ``py::dict``), or in a +worse case scenario, it will silently work but corrupt the types you want to +work with (e.g. ``py::str(py::none())`` will yield ``"None"`` in Python). diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/pycpp/utilities.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/pycpp/utilities.rst new file mode 100644 index 000000000..af0f9cb2b --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/pycpp/utilities.rst @@ -0,0 +1,155 @@ +Utilities +######### + +Using Python's print function in C++ +==================================== + +The usual way to write output in C++ is using ``std::cout`` while in Python one +would use ``print``. Since these methods use different buffers, mixing them can +lead to output order issues. To resolve this, pybind11 modules can use the +:func:`py::print` function which writes to Python's ``sys.stdout`` for consistency. + +Python's ``print`` function is replicated in the C++ API including optional +keyword arguments ``sep``, ``end``, ``file``, ``flush``. Everything works as +expected in Python: + +.. code-block:: cpp + + py::print(1, 2.0, "three"); // 1 2.0 three + py::print(1, 2.0, "three", "sep"_a="-"); // 1-2.0-three + + auto args = py::make_tuple("unpacked", true); + py::print("->", *args, "end"_a="<-"); // -> unpacked True <- + +.. _ostream_redirect: + +Capturing standard output from ostream +====================================== + +Often, a library will use the streams ``std::cout`` and ``std::cerr`` to print, +but this does not play well with Python's standard ``sys.stdout`` and ``sys.stderr`` +redirection. Replacing a library's printing with ``py::print `` may not +be feasible. This can be fixed using a guard around the library function that +redirects output to the corresponding Python streams: + +.. code-block:: cpp + + #include + + ... + + // Add a scoped redirect for your noisy code + m.def("noisy_func", []() { + py::scoped_ostream_redirect stream( + std::cout, // std::ostream& + py::module_::import("sys").attr("stdout") // Python output + ); + call_noisy_func(); + }); + +.. warning:: + + The implementation in ``pybind11/iostream.h`` is NOT thread safe. Multiple + threads writing to a redirected ostream concurrently cause data races + and potentially buffer overflows. Therefore it is currently a requirement + that all (possibly) concurrent redirected ostream writes are protected by + a mutex. #HelpAppreciated: Work on iostream.h thread safety. For more + background see the discussions under + `PR #2982 `_ and + `PR #2995 `_. + +This method respects flushes on the output streams and will flush if needed +when the scoped guard is destroyed. This allows the output to be redirected in +real time, such as to a Jupyter notebook. The two arguments, the C++ stream and +the Python output, are optional, and default to standard output if not given. An +extra type, ``py::scoped_estream_redirect ``, is identical +except for defaulting to ``std::cerr`` and ``sys.stderr``; this can be useful with +``py::call_guard``, which allows multiple items, but uses the default constructor: + +.. code-block:: cpp + + // Alternative: Call single function using call guard + m.def("noisy_func", &call_noisy_function, + py::call_guard()); + +The redirection can also be done in Python with the addition of a context +manager, using the ``py::add_ostream_redirect() `` function: + +.. code-block:: cpp + + py::add_ostream_redirect(m, "ostream_redirect"); + +The name in Python defaults to ``ostream_redirect`` if no name is passed. This +creates the following context manager in Python: + +.. code-block:: python + + with ostream_redirect(stdout=True, stderr=True): + noisy_function() + +It defaults to redirecting both streams, though you can use the keyword +arguments to disable one of the streams if needed. + +.. note:: + + The above methods will not redirect C-level output to file descriptors, such + as ``fprintf``. For those cases, you'll need to redirect the file + descriptors either directly in C or with Python's ``os.dup2`` function + in an operating-system dependent way. + +.. _eval: + +Evaluating Python expressions from strings and files +==================================================== + +pybind11 provides the ``eval``, ``exec`` and ``eval_file`` functions to evaluate +Python expressions and statements. The following example illustrates how they +can be used. + +.. code-block:: cpp + + // At beginning of file + #include + + ... + + // Evaluate in scope of main module + py::object scope = py::module_::import("__main__").attr("__dict__"); + + // Evaluate an isolated expression + int result = py::eval("my_variable + 10", scope).cast(); + + // Evaluate a sequence of statements + py::exec( + "print('Hello')\n" + "print('world!');", + scope); + + // Evaluate the statements in an separate Python file on disk + py::eval_file("script.py", scope); + +C++11 raw string literals are also supported and quite handy for this purpose. +The only requirement is that the first statement must be on a new line following +the raw string delimiter ``R"(``, ensuring all lines have common leading indent: + +.. code-block:: cpp + + py::exec(R"( + x = get_answer() + if x == 42: + print('Hello World!') + else: + print('Bye!') + )", scope + ); + +.. note:: + + `eval` and `eval_file` accept a template parameter that describes how the + string/file should be interpreted. Possible choices include ``eval_expr`` + (isolated expression), ``eval_single_statement`` (a single statement, return + value is always ``none``), and ``eval_statements`` (sequence of statements, + return value is always ``none``). `eval` defaults to ``eval_expr``, + `eval_file` defaults to ``eval_statements`` and `exec` is just a shortcut + for ``eval``. diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/smart_ptrs.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/smart_ptrs.rst new file mode 100644 index 000000000..3c40ce123 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/advanced/smart_ptrs.rst @@ -0,0 +1,174 @@ +Smart pointers +############## + +std::unique_ptr +=============== + +Given a class ``Example`` with Python bindings, it's possible to return +instances wrapped in C++11 unique pointers, like so + +.. code-block:: cpp + + std::unique_ptr create_example() { return std::unique_ptr(new Example()); } + +.. code-block:: cpp + + m.def("create_example", &create_example); + +In other words, there is nothing special that needs to be done. While returning +unique pointers in this way is allowed, it is *illegal* to use them as function +arguments. For instance, the following function signature cannot be processed +by pybind11. + +.. code-block:: cpp + + void do_something_with_example(std::unique_ptr ex) { ... } + +The above signature would imply that Python needs to give up ownership of an +object that is passed to this function, which is generally not possible (for +instance, the object might be referenced elsewhere). + +std::shared_ptr +=============== + +The binding generator for classes, :class:`class_`, can be passed a template +type that denotes a special *holder* type that is used to manage references to +the object. If no such holder type template argument is given, the default for +a type named ``Type`` is ``std::unique_ptr``, which means that the object +is deallocated when Python's reference count goes to zero. + +It is possible to switch to other types of reference counting wrappers or smart +pointers, which is useful in codebases that rely on them. For instance, the +following snippet causes ``std::shared_ptr`` to be used instead. + +.. code-block:: cpp + + py::class_ /* <- holder type */> obj(m, "Example"); + +Note that any particular class can only be associated with a single holder type. + +One potential stumbling block when using holder types is that they need to be +applied consistently. Can you guess what's broken about the following binding +code? + +.. code-block:: cpp + + class Child { }; + + class Parent { + public: + Parent() : child(std::make_shared()) { } + Child *get_child() { return child.get(); } /* Hint: ** DON'T DO THIS ** */ + private: + std::shared_ptr child; + }; + + PYBIND11_MODULE(example, m) { + py::class_>(m, "Child"); + + py::class_>(m, "Parent") + .def(py::init<>()) + .def("get_child", &Parent::get_child); + } + +The following Python code will cause undefined behavior (and likely a +segmentation fault). + +.. code-block:: python + + from example import Parent + + print(Parent().get_child()) + +The problem is that ``Parent::get_child()`` returns a pointer to an instance of +``Child``, but the fact that this instance is already managed by +``std::shared_ptr<...>`` is lost when passing raw pointers. In this case, +pybind11 will create a second independent ``std::shared_ptr<...>`` that also +claims ownership of the pointer. In the end, the object will be freed **twice** +since these shared pointers have no way of knowing about each other. + +There are two ways to resolve this issue: + +1. For types that are managed by a smart pointer class, never use raw pointers + in function arguments or return values. In other words: always consistently + wrap pointers into their designated holder types (such as + ``std::shared_ptr<...>``). In this case, the signature of ``get_child()`` + should be modified as follows: + +.. code-block:: cpp + + std::shared_ptr get_child() { return child; } + +2. Adjust the definition of ``Child`` by specifying + ``std::enable_shared_from_this`` (see cppreference_ for details) as a + base class. This adds a small bit of information to ``Child`` that allows + pybind11 to realize that there is already an existing + ``std::shared_ptr<...>`` and communicate with it. In this case, the + declaration of ``Child`` should look as follows: + +.. _cppreference: http://en.cppreference.com/w/cpp/memory/enable_shared_from_this + +.. code-block:: cpp + + class Child : public std::enable_shared_from_this { }; + +.. _smart_pointers: + +Custom smart pointers +===================== + +pybind11 supports ``std::unique_ptr`` and ``std::shared_ptr`` right out of the +box. For any other custom smart pointer, transparent conversions can be enabled +using a macro invocation similar to the following. It must be declared at the +top namespace level before any binding code: + +.. code-block:: cpp + + PYBIND11_DECLARE_HOLDER_TYPE(T, SmartPtr); + +The first argument of :func:`PYBIND11_DECLARE_HOLDER_TYPE` should be a +placeholder name that is used as a template parameter of the second argument. +Thus, feel free to use any identifier, but use it consistently on both sides; +also, don't use the name of a type that already exists in your codebase. + +The macro also accepts a third optional boolean parameter that is set to false +by default. Specify + +.. code-block:: cpp + + PYBIND11_DECLARE_HOLDER_TYPE(T, SmartPtr, true); + +if ``SmartPtr`` can always be initialized from a ``T*`` pointer without the +risk of inconsistencies (such as multiple independent ``SmartPtr`` instances +believing that they are the sole owner of the ``T*`` pointer). A common +situation where ``true`` should be passed is when the ``T`` instances use +*intrusive* reference counting. + +Please take a look at the :ref:`macro_notes` before using this feature. + +By default, pybind11 assumes that your custom smart pointer has a standard +interface, i.e. provides a ``.get()`` member function to access the underlying +raw pointer. If this is not the case, pybind11's ``holder_helper`` must be +specialized: + +.. code-block:: cpp + + // Always needed for custom holder types + PYBIND11_DECLARE_HOLDER_TYPE(T, SmartPtr); + + // Only needed if the type's `.get()` goes by another name + namespace PYBIND11_NAMESPACE { namespace detail { + template + struct holder_helper> { // <-- specialization + static const T *get(const SmartPtr &p) { return p.getPointer(); } + }; + }} + +The above specialization informs pybind11 that the custom ``SmartPtr`` class +provides ``.get()`` functionality via ``.getPointer()``. + +.. seealso:: + + The file :file:`tests/test_smart_ptr.cpp` contains a complete example + that demonstrates how to work with custom reference-counting holder types + in more detail. diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/basics.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/basics.rst new file mode 100644 index 000000000..e9b24c7fa --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/basics.rst @@ -0,0 +1,307 @@ +.. _basics: + +First steps +########### + +This sections demonstrates the basic features of pybind11. Before getting +started, make sure that development environment is set up to compile the +included set of test cases. + + +Compiling the test cases +======================== + +Linux/macOS +----------- + +On Linux you'll need to install the **python-dev** or **python3-dev** packages as +well as **cmake**. On macOS, the included python version works out of the box, +but **cmake** must still be installed. + +After installing the prerequisites, run + +.. code-block:: bash + + mkdir build + cd build + cmake .. + make check -j 4 + +The last line will both compile and run the tests. + +Windows +------- + +On Windows, only **Visual Studio 2017** and newer are supported. + +.. Note:: + + To use the C++17 in Visual Studio 2017 (MSVC 14.1), pybind11 requires the flag + ``/permissive-`` to be passed to the compiler `to enforce standard conformance`_. When + building with Visual Studio 2019, this is not strictly necessary, but still advised. + +.. _`to enforce standard conformance`: https://docs.microsoft.com/en-us/cpp/build/reference/permissive-standards-conformance?view=vs-2017 + +To compile and run the tests: + +.. code-block:: batch + + mkdir build + cd build + cmake .. + cmake --build . --config Release --target check + +This will create a Visual Studio project, compile and run the target, all from the +command line. + +.. Note:: + + If all tests fail, make sure that the Python binary and the testcases are compiled + for the same processor type and bitness (i.e. either **i386** or **x86_64**). You + can specify **x86_64** as the target architecture for the generated Visual Studio + project using ``cmake -A x64 ..``. + +.. seealso:: + + Advanced users who are already familiar with Boost.Python may want to skip + the tutorial and look at the test cases in the :file:`tests` directory, + which exercise all features of pybind11. + +Header and namespace conventions +================================ + +For brevity, all code examples assume that the following two lines are present: + +.. code-block:: cpp + + #include + + namespace py = pybind11; + +Some features may require additional headers, but those will be specified as needed. + +.. _simple_example: + +Creating bindings for a simple function +======================================= + +Let's start by creating Python bindings for an extremely simple function, which +adds two numbers and returns their result: + +.. code-block:: cpp + + int add(int i, int j) { + return i + j; + } + +For simplicity [#f1]_, we'll put both this function and the binding code into +a file named :file:`example.cpp` with the following contents: + +.. code-block:: cpp + + #include + + int add(int i, int j) { + return i + j; + } + + PYBIND11_MODULE(example, m) { + m.doc() = "pybind11 example plugin"; // optional module docstring + + m.def("add", &add, "A function that adds two numbers"); + } + +.. [#f1] In practice, implementation and binding code will generally be located + in separate files. + +The :func:`PYBIND11_MODULE` macro creates a function that will be called when an +``import`` statement is issued from within Python. The module name (``example``) +is given as the first macro argument (it should not be in quotes). The second +argument (``m``) defines a variable of type :class:`py::module_ ` which +is the main interface for creating bindings. The method :func:`module_::def` +generates binding code that exposes the ``add()`` function to Python. + +.. note:: + + Notice how little code was needed to expose our function to Python: all + details regarding the function's parameters and return value were + automatically inferred using template metaprogramming. This overall + approach and the used syntax are borrowed from Boost.Python, though the + underlying implementation is very different. + +pybind11 is a header-only library, hence it is not necessary to link against +any special libraries and there are no intermediate (magic) translation steps. +On Linux, the above example can be compiled using the following command: + +.. code-block:: bash + + $ c++ -O3 -Wall -shared -std=c++11 -fPIC $(python3 -m pybind11 --includes) example.cpp -o example$(python3-config --extension-suffix) + +.. note:: + + If you used :ref:`include_as_a_submodule` to get the pybind11 source, then + use ``$(python3-config --includes) -Iextern/pybind11/include`` instead of + ``$(python3 -m pybind11 --includes)`` in the above compilation, as + explained in :ref:`building_manually`. + +For more details on the required compiler flags on Linux and macOS, see +:ref:`building_manually`. For complete cross-platform compilation instructions, +refer to the :ref:`compiling` page. + +The `python_example`_ and `cmake_example`_ repositories are also a good place +to start. They are both complete project examples with cross-platform build +systems. The only difference between the two is that `python_example`_ uses +Python's ``setuptools`` to build the module, while `cmake_example`_ uses CMake +(which may be preferable for existing C++ projects). + +.. _python_example: https://github.com/pybind/python_example +.. _cmake_example: https://github.com/pybind/cmake_example + +Building the above C++ code will produce a binary module file that can be +imported to Python. Assuming that the compiled module is located in the +current directory, the following interactive Python session shows how to +load and execute the example: + +.. code-block:: pycon + + $ python + Python 3.9.10 (main, Jan 15 2022, 11:48:04) + [Clang 13.0.0 (clang-1300.0.29.3)] on darwin + Type "help", "copyright", "credits" or "license" for more information. + >>> import example + >>> example.add(1, 2) + 3 + >>> + +.. _keyword_args: + +Keyword arguments +================= + +With a simple code modification, it is possible to inform Python about the +names of the arguments ("i" and "j" in this case). + +.. code-block:: cpp + + m.def("add", &add, "A function which adds two numbers", + py::arg("i"), py::arg("j")); + +:class:`arg` is one of several special tag classes which can be used to pass +metadata into :func:`module_::def`. With this modified binding code, we can now +call the function using keyword arguments, which is a more readable alternative +particularly for functions taking many parameters: + +.. code-block:: pycon + + >>> import example + >>> example.add(i=1, j=2) + 3L + +The keyword names also appear in the function signatures within the documentation. + +.. code-block:: pycon + + >>> help(example) + + .... + + FUNCTIONS + add(...) + Signature : (i: int, j: int) -> int + + A function which adds two numbers + +A shorter notation for named arguments is also available: + +.. code-block:: cpp + + // regular notation + m.def("add1", &add, py::arg("i"), py::arg("j")); + // shorthand + using namespace pybind11::literals; + m.def("add2", &add, "i"_a, "j"_a); + +The :var:`_a` suffix forms a C++11 literal which is equivalent to :class:`arg`. +Note that the literal operator must first be made visible with the directive +``using namespace pybind11::literals``. This does not bring in anything else +from the ``pybind11`` namespace except for literals. + +.. _default_args: + +Default arguments +================= + +Suppose now that the function to be bound has default arguments, e.g.: + +.. code-block:: cpp + + int add(int i = 1, int j = 2) { + return i + j; + } + +Unfortunately, pybind11 cannot automatically extract these parameters, since they +are not part of the function's type information. However, they are simple to specify +using an extension of :class:`arg`: + +.. code-block:: cpp + + m.def("add", &add, "A function which adds two numbers", + py::arg("i") = 1, py::arg("j") = 2); + +The default values also appear within the documentation. + +.. code-block:: pycon + + >>> help(example) + + .... + + FUNCTIONS + add(...) + Signature : (i: int = 1, j: int = 2) -> int + + A function which adds two numbers + +The shorthand notation is also available for default arguments: + +.. code-block:: cpp + + // regular notation + m.def("add1", &add, py::arg("i") = 1, py::arg("j") = 2); + // shorthand + m.def("add2", &add, "i"_a=1, "j"_a=2); + +Exporting variables +=================== + +To expose a value from C++, use the ``attr`` function to register it in a +module as shown below. Built-in types and general objects (more on that later) +are automatically converted when assigned as attributes, and can be explicitly +converted using the function ``py::cast``. + +.. code-block:: cpp + + PYBIND11_MODULE(example, m) { + m.attr("the_answer") = 42; + py::object world = py::cast("World"); + m.attr("what") = world; + } + +These are then accessible from Python: + +.. code-block:: pycon + + >>> import example + >>> example.the_answer + 42 + >>> example.what + 'World' + +.. _supported_types: + +Supported data types +==================== + +A large number of data types are supported out of the box and can be used +seamlessly as functions arguments, return values or with ``py::cast`` in general. +For a full overview, see the :doc:`advanced/cast/index` section. diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/benchmark.py b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/benchmark.py new file mode 100644 index 000000000..2150b6ca7 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/benchmark.py @@ -0,0 +1,87 @@ +import datetime as dt +import os +import random + +nfns = 4 # Functions per class +nargs = 4 # Arguments per function + + +def generate_dummy_code_pybind11(nclasses=10): + decl = "" + bindings = "" + + for cl in range(nclasses): + decl += f"class cl{cl:03};\n" + decl += "\n" + + for cl in range(nclasses): + decl += f"class {cl:03} {{\n" + decl += "public:\n" + bindings += f' py::class_(m, "cl{cl:03}")\n' + for fn in range(nfns): + ret = random.randint(0, nclasses - 1) + params = [random.randint(0, nclasses - 1) for i in range(nargs)] + decl += f" cl{ret:03} *fn_{fn:03}(" + decl += ", ".join(f"cl{p:03} *" for p in params) + decl += ");\n" + bindings += f' .def("fn_{fn:03}", &cl{cl:03}::fn_{fn:03})\n' + decl += "};\n\n" + bindings += " ;\n" + + result = "#include \n\n" + result += "namespace py = pybind11;\n\n" + result += decl + "\n" + result += "PYBIND11_MODULE(example, m) {\n" + result += bindings + result += "}" + return result + + +def generate_dummy_code_boost(nclasses=10): + decl = "" + bindings = "" + + for cl in range(nclasses): + decl += f"class cl{cl:03};\n" + decl += "\n" + + for cl in range(nclasses): + decl += "class cl%03i {\n" % cl + decl += "public:\n" + bindings += f' py::class_("cl{cl:03}")\n' + for fn in range(nfns): + ret = random.randint(0, nclasses - 1) + params = [random.randint(0, nclasses - 1) for i in range(nargs)] + decl += f" cl{ret:03} *fn_{fn:03}(" + decl += ", ".join(f"cl{p:03} *" for p in params) + decl += ");\n" + bindings += f' .def("fn_{fn:03}", &cl{cl:03}::fn_{fn:03}, py::return_value_policy())\n' + decl += "};\n\n" + bindings += " ;\n" + + result = "#include \n\n" + result += "namespace py = boost::python;\n\n" + result += decl + "\n" + result += "BOOST_PYTHON_MODULE(example) {\n" + result += bindings + result += "}" + return result + + +for codegen in [generate_dummy_code_pybind11, generate_dummy_code_boost]: + print("{") + for i in range(0, 10): + nclasses = 2**i + with open("test.cpp", "w") as f: + f.write(codegen(nclasses)) + n1 = dt.datetime.now() + os.system( + "g++ -Os -shared -rdynamic -undefined dynamic_lookup " + "-fvisibility=hidden -std=c++14 test.cpp -I include " + "-I /System/Library/Frameworks/Python.framework/Headers -o test.so" + ) + n2 = dt.datetime.now() + elapsed = (n2 - n1).total_seconds() + size = os.stat("test.so").st_size + print(" {%i, %f, %i}," % (nclasses * nfns, elapsed, size)) + print("}") diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/benchmark.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/benchmark.rst new file mode 100644 index 000000000..02c2ccde7 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/benchmark.rst @@ -0,0 +1,95 @@ +Benchmark +========= + +The following is the result of a synthetic benchmark comparing both compilation +time and module size of pybind11 against Boost.Python. A detailed report about a +Boost.Python to pybind11 conversion of a real project is available here: [#f1]_. + +.. [#f1] http://graylab.jhu.edu/RosettaCon2016/PyRosetta-4.pdf + +Setup +----- + +A python script (see the ``docs/benchmark.py`` file) was used to generate a set +of files with dummy classes whose count increases for each successive benchmark +(between 1 and 2048 classes in powers of two). Each class has four methods with +a randomly generated signature with a return value and four arguments. (There +was no particular reason for this setup other than the desire to generate many +unique function signatures whose count could be controlled in a simple way.) + +Here is an example of the binding code for one class: + +.. code-block:: cpp + + ... + class cl034 { + public: + cl279 *fn_000(cl084 *, cl057 *, cl065 *, cl042 *); + cl025 *fn_001(cl098 *, cl262 *, cl414 *, cl121 *); + cl085 *fn_002(cl445 *, cl297 *, cl145 *, cl421 *); + cl470 *fn_003(cl200 *, cl323 *, cl332 *, cl492 *); + }; + ... + + PYBIND11_MODULE(example, m) { + ... + py::class_(m, "cl034") + .def("fn_000", &cl034::fn_000) + .def("fn_001", &cl034::fn_001) + .def("fn_002", &cl034::fn_002) + .def("fn_003", &cl034::fn_003) + ... + } + +The Boost.Python version looks almost identical except that a return value +policy had to be specified as an argument to ``def()``. For both libraries, +compilation was done with + +.. code-block:: bash + + Apple LLVM version 7.0.2 (clang-700.1.81) + +and the following compilation flags + +.. code-block:: bash + + g++ -Os -shared -rdynamic -undefined dynamic_lookup -fvisibility=hidden -std=c++14 + +Compilation time +---------------- + +The following log-log plot shows how the compilation time grows for an +increasing number of class and function declarations. pybind11 includes many +fewer headers, which initially leads to shorter compilation times, but the +performance is ultimately fairly similar (pybind11 is 19.8 seconds faster for +the largest largest file with 2048 classes and a total of 8192 methods -- a +modest **1.2x** speedup relative to Boost.Python, which required 116.35 +seconds). + +.. only:: not latex + + .. image:: pybind11_vs_boost_python1.svg + +.. only:: latex + + .. image:: pybind11_vs_boost_python1.png + +Module size +----------- + +Differences between the two libraries become much more pronounced when +considering the file size of the generated Python plugin: for the largest file, +the binary generated by Boost.Python required 16.8 MiB, which was **2.17 +times** / **9.1 megabytes** larger than the output generated by pybind11. For +very small inputs, Boost.Python has an edge in the plot below -- however, note +that it stores many definitions in an external library, whose size was not +included here, hence the comparison is slightly shifted in Boost.Python's +favor. + +.. only:: not latex + + .. image:: pybind11_vs_boost_python2.svg + +.. only:: latex + + .. image:: pybind11_vs_boost_python2.png diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/changelog.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/changelog.rst new file mode 100644 index 000000000..8e5c49658 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/changelog.rst @@ -0,0 +1,2832 @@ +.. _changelog: + +Changelog +######### + +Starting with version 1.8.0, pybind11 releases use a `semantic versioning +`_ policy. + +Changes will be added here periodically from the "Suggested changelog entry" +block in pull request descriptions. + + +IN DEVELOPMENT +-------------- + +Changes will be summarized here periodically. + + +Version 2.11.1 (July 17, 2023) +----------------------------- + +Changes: + +* ``PYBIND11_NO_ASSERT_GIL_HELD_INCREF_DECREF`` is now provided as an option + for disabling the default-on ``PyGILState_Check()``'s in + ``pybind11::handle``'s ``inc_ref()`` & ``dec_ref()``. + `#4753 `_ + +* ``PYBIND11_ASSERT_GIL_HELD_INCREF_DECREF`` was disabled for PyPy in general + (not just PyPy Windows). + `#4751 `_ + + +Version 2.11.0 (July 14, 2023) +----------------------------- + +New features: + +* The newly added ``pybind11::detail::is_move_constructible`` trait can be + specialized for cases in which ``std::is_move_constructible`` does not work + as needed. This is very similar to the long-established + ``pybind11::detail::is_copy_constructible``. + `#4631 `_ + +* Introduce ``recursive_container_traits``. + `#4623 `_ + +* ``pybind11/type_caster_pyobject_ptr.h`` was added to support automatic + wrapping of APIs that make use of ``PyObject *``. This header needs to + included explicitly (i.e. it is not included implicitly + with ``pybind/pybind11.h``). + `#4601 `_ + +* ``format_descriptor<>`` & ``npy_format_descriptor<>`` ``PyObject *`` + specializations were added. The latter enables ``py::array_t`` + to/from-python conversions. + `#4674 `_ + +* ``buffer_info`` gained an ``item_type_is_equivalent_to()`` member + function. + `#4674 `_ + +* The ``capsule`` API gained a user-friendly constructor + (``py::capsule(ptr, "name", dtor)``). + `#4720 `_ + +Changes: + +* ``PyGILState_Check()``'s in ``pybind11::handle``'s ``inc_ref()`` & + ``dec_ref()`` are now enabled by default again. + `#4246 `_ + +* ``py::initialize_interpreter()`` using ``PyConfig_InitPythonConfig()`` + instead of ``PyConfig_InitIsolatedConfig()``, to obtain complete + ``sys.path``. + `#4473 `_ + +* Cast errors now always include Python type information, even if + ``PYBIND11_DETAILED_ERROR_MESSAGES`` is not defined. This increases binary + sizes slightly (~1.5%) but the error messages are much more informative. + `#4463 `_ + +* The docstring generation for the ``std::array``-list caster was fixed. + Previously, signatures included the size of the list in a non-standard, + non-spec compliant way. The new format conforms to PEP 593. + **Tooling for processing the docstrings may need to be updated accordingly.** + `#4679 `_ + +* Setter return values (which are inaccessible for all practical purposes) are + no longer converted to Python (only to be discarded). + `#4621 `_ + +* Allow lambda specified to function definition to be ``noexcept(true)`` + in C++17. + `#4593 `_ + +* Get rid of recursive template instantiations for concatenating type + signatures on C++17 and higher. + `#4587 `_ + +* Compatibility with Python 3.12 (beta). Note that the minimum pybind11 + ABI version for Python 3.12 is version 5. (The default ABI version + for Python versions up to and including 3.11 is still version 4.). + `#4570 `_ + +* With ``PYBIND11_INTERNALS_VERSION 5`` (default for Python 3.12+), MSVC builds + use ``std::hash`` and ``std::equal_to`` + instead of string-based type comparisons. This resolves issues when binding + types defined in the unnamed namespace. + `#4319 `_ + +* Python exception ``__notes__`` (introduced with Python 3.11) are now added to + the ``error_already_set::what()`` output. + `#4678 `_ + +Build system improvements: + +* CMake 3.27 support was added, CMake 3.4 support was dropped. + FindPython will be used if ``FindPythonInterp`` is not present. + `#4719 `_ + +* Update clang-tidy to 15 in CI. + `#4387 `_ + +* Moved the linting framework over to Ruff. + `#4483 `_ + +* Skip ``lto`` checks and target generation when + ``CMAKE_INTERPROCEDURAL_OPTIMIZATION`` is defined. + `#4643 `_ + +* No longer inject ``-stdlib=libc++``, not needed for modern Pythons + (macOS 10.9+). + `#4639 `_ + +* PyPy 3.10 support was added, PyPy 3.7 support was dropped. + `#4728 `_ + +* Testing with Python 3.12 beta releases was added. + `#4713 `_ + + +Version 2.10.4 (Mar 16, 2023) +----------------------------- + +Changes: + +* ``python3 -m pybind11`` gained a ``--version`` option (prints the version and + exits). + `#4526 `_ + +Bug Fixes: + +* Fix a warning when pydebug is enabled on Python 3.11. + `#4461 `_ + +* Ensure ``gil_scoped_release`` RAII is non-copyable. + `#4490 `_ + +* Ensure the tests dir does not show up with new versions of setuptools. + `#4510 `_ + +* Better stacklevel for a warning in setuptools helpers. + `#4516 `_ + +Version 2.10.3 (Jan 3, 2023) +---------------------------- + +Changes: + +* Temporarily made our GIL status assertions (added in 2.10.2) disabled by + default (re-enable manually by defining + ``PYBIND11_ASSERT_GIL_HELD_INCREF_DECREF``, will be enabled in 2.11). + `#4432 `_ + +* Improved error messages when ``inc_ref``/``dec_ref`` are called with an + invalid GIL state. + `#4427 `_ + `#4436 `_ + +Bug Fixes: + +* Some minor touchups found by static analyzers. + `#4440 `_ + + +Version 2.10.2 (Dec 20, 2022) +----------------------------- + +Changes: + +* ``scoped_interpreter`` constructor taking ``PyConfig``. + `#4330 `_ + +* ``pybind11/eigen/tensor.h`` adds converters to and from ``Eigen::Tensor`` and + ``Eigen::TensorMap``. + `#4201 `_ + +* ``PyGILState_Check()``'s were integrated to ``pybind11::handle`` + ``inc_ref()`` & ``dec_ref()``. The added GIL checks are guarded by + ``PYBIND11_ASSERT_GIL_HELD_INCREF_DECREF``, which is the default only if + ``NDEBUG`` is not defined. (Made non-default in 2.10.3, will be active in 2.11) + `#4246 `_ + +* Add option for enable/disable enum members in docstring. + `#2768 `_ + +* Fixed typing of ``KeysView``, ``ValuesView`` and ``ItemsView`` in ``bind_map``. + `#4353 `_ + +Bug fixes: + +* Bug fix affecting only Python 3.6 under very specific, uncommon conditions: + move ``PyEval_InitThreads()`` call to the correct location. + `#4350 `_ + +* Fix segfault bug when passing foreign native functions to functional.h. + `#4254 `_ + +Build system improvements: + +* Support setting PYTHON_LIBRARIES manually for Windows ARM cross-compilation + (classic mode). + `#4406 `_ + +* Extend IPO/LTO detection for ICX (a.k.a IntelLLVM) compiler. + `#4402 `_ + +* Allow calling ``find_package(pybind11 CONFIG)`` multiple times from separate + directories in the same CMake project and properly link Python (new mode). + `#4401 `_ + +* ``multiprocessing_set_spawn`` in pytest fixture for added safety. + `#4377 `_ + +* Fixed a bug in two pybind11/tools cmake scripts causing "Unknown arguments specified" errors. + `#4327 `_ + + + +Version 2.10.1 (Oct 31, 2022) +----------------------------- + +This is the first version to fully support embedding the newly released Python 3.11. + +Changes: + +* Allow ``pybind11::capsule`` constructor to take null destructor pointers. + `#4221 `_ + +* ``embed.h`` was changed so that ``PYTHONPATH`` is used also with Python 3.11 + (established behavior). + `#4119 `_ + +* A ``PYBIND11_SIMPLE_GIL_MANAGEMENT`` option was added (cmake, C++ define), + along with many additional tests in ``test_gil_scoped.py``. The option may be + useful to try when debugging GIL-related issues, to determine if the more + complex default implementation is or is not to blame. See #4216 for + background. WARNING: Please be careful to not create ODR violations when + using the option: everything that is linked together with mutual symbol + visibility needs to be rebuilt. + `#4216 `_ + +* ``PYBIND11_EXPORT_EXCEPTION`` was made non-empty only under macOS. This makes + Linux builds safer, and enables the removal of warning suppression pragmas for + Windows. + `#4298 `_ + +Bug fixes: + +* Fixed a bug where ``UnicodeDecodeError`` was not propagated from various + ``py::str`` ctors when decoding surrogate utf characters. + `#4294 `_ + +* Revert perfect forwarding for ``make_iterator``. This broke at least one + valid use case. May revisit later. + `#4234 `_ + +* Fix support for safe casts to ``void*`` (regression in 2.10.0). + `#4275 `_ + +* Fix ``char8_t`` support (regression in 2.9). + `#4278 `_ + +* Unicode surrogate character in Python exception message leads to process + termination in ``error_already_set::what()``. + `#4297 `_ + +* Fix MSVC 2019 v.1924 & C++14 mode error for ``overload_cast``. + `#4188 `_ + +* Make augmented assignment operators non-const for the object-api. Behavior + was previously broken for augmented assignment operators. + `#4065 `_ + +* Add proper error checking to C++ bindings for Python list append and insert. + `#4208 `_ + +* Work-around for Nvidia's CUDA nvcc compiler in versions 11.4.0 - 11.8.0. + `#4220 `_ + +* A workaround for PyPy was added in the ``py::error_already_set`` + implementation, related to PR `#1895 `_ + released with v2.10.0. + `#4079 `_ + +* Fixed compiler errors when C++23 ``std::forward_like`` is available. + `#4136 `_ + +* Properly raise exceptions in contains methods (like when an object in unhashable). + `#4209 `_ + +* Further improve another error in exception handling. + `#4232 `_ + +* ``get_local_internals()`` was made compatible with + ``finalize_interpreter()``, fixing potential freezes during interpreter + finalization. + `#4192 `_ + +Performance and style: + +* Reserve space in set and STL map casters if possible. This will prevent + unnecessary rehashing / resizing by knowing the number of keys ahead of time + for Python to C++ casting. This improvement will greatly speed up the casting + of large unordered maps and sets. + `#4194 `_ + +* GIL RAII scopes are non-copyable to avoid potential bugs. + `#4183 `_ + +* Explicitly default all relevant ctors for pytypes in the ``PYBIND11_OBJECT`` + macros and enforce the clang-tidy checks ``modernize-use-equals-default`` in + macros as well. + `#4017 `_ + +* Optimize iterator advancement in C++ bindings. + `#4237 `_ + +* Use the modern ``PyObject_GenericGetDict`` and ``PyObject_GenericSetDict`` + for handling dynamic attribute dictionaries. + `#4106 `_ + +* Document that users should use ``PYBIND11_NAMESPACE`` instead of using ``pybind11`` when + opening namespaces. Using namespace declarations and namespace qualification + remain the same as ``pybind11``. This is done to ensure consistent symbol + visibility. + `#4098 `_ + +* Mark ``detail::forward_like`` as constexpr. + `#4147 `_ + +* Optimize unpacking_collector when processing ``arg_v`` arguments. + `#4219 `_ + +* Optimize casting C++ object to ``None``. + `#4269 `_ + + +Build system improvements: + +* CMake: revert overwrite behavior, now opt-in with ``PYBIND11_PYTHONLIBS_OVERRWRITE OFF``. + `#4195 `_ + +* Include a pkg-config file when installing pybind11, such as in the Python + package. + `#4077 `_ + +* Avoid stripping debug symbols when ``CMAKE_BUILD_TYPE`` is set to ``DEBUG`` + instead of ``Debug``. + `#4078 `_ + +* Followup to `#3948 `_, fixing vcpkg again. + `#4123 `_ + +Version 2.10.0 (Jul 15, 2022) +----------------------------- + +Removed support for Python 2.7, Python 3.5, and MSVC 2015. Support for MSVC +2017 is limited due to availability of CI runners; we highly recommend MSVC +2019 or 2022 be used. Initial support added for Python 3.11. + +New features: + +* ``py::anyset`` & ``py::frozenset`` were added, with copying (cast) to + ``std::set`` (similar to ``set``). + `#3901 `_ + +* Support bytearray casting to string. + `#3707 `_ + +* ``type_caster`` was added. ``std::monostate`` is a tag type + that allows ``std::variant`` to act as an optional, or allows default + construction of a ``std::variant`` holding a non-default constructible type. + `#3818 `_ + +* ``pybind11::capsule::set_name`` added to mutate the name of the capsule instance. + `#3866 `_ + +* NumPy: dtype constructor from type number added, accessors corresponding to + Python API ``dtype.num``, ``dtype.byteorder``, ``dtype.flags`` and + ``dtype.alignment`` added. + `#3868 `_ + + +Changes: + +* Python 3.6 is now the minimum supported version. + `#3688 `_ + `#3719 `_ + +* The minimum version for MSVC is now 2017. + `#3722 `_ + +* Fix issues with CPython 3.11 betas and add to supported test matrix. + `#3923 `_ + +* ``error_already_set`` is now safer and more performant, especially for + exceptions with long tracebacks, by delaying computation. + `#1895 `_ + +* Improve exception handling in python ``str`` bindings. + `#3826 `_ + +* The bindings for capsules now have more consistent exception handling. + `#3825 `_ + +* ``PYBIND11_OBJECT_CVT`` and ``PYBIND11_OBJECT_CVT_DEFAULT`` macro can now be + used to define classes in namespaces other than pybind11. + `#3797 `_ + +* Error printing code now uses ``PYBIND11_DETAILED_ERROR_MESSAGES`` instead of + requiring ``NDEBUG``, allowing use with release builds if desired. + `#3913 `_ + +* Implicit conversion of the literal ``0`` to ``pybind11::handle`` is now disabled. + `#4008 `_ + + +Bug fixes: + +* Fix exception handling when ``pybind11::weakref()`` fails. + `#3739 `_ + +* ``module_::def_submodule`` was missing proper error handling. This is fixed now. + `#3973 `_ + +* The behavior or ``error_already_set`` was made safer and the highly opaque + "Unknown internal error occurred" message was replaced with a more helpful + message. + `#3982 `_ + +* ``error_already_set::what()`` now handles non-normalized exceptions correctly. + `#3971 `_ + +* Support older C++ compilers where filesystem is not yet part of the standard + library and is instead included in ``std::experimental::filesystem``. + `#3840 `_ + +* Fix ``-Wfree-nonheap-object`` warnings produced by GCC by avoiding returning + pointers to static objects with ``return_value_policy::take_ownership``. + `#3946 `_ + +* Fix cast from pytype rvalue to another pytype. + `#3949 `_ + +* Ensure proper behavior when garbage collecting classes with dynamic attributes in Python >=3.9. + `#4051 `_ + +* A couple long-standing ``PYBIND11_NAMESPACE`` + ``__attribute__((visibility("hidden")))`` inconsistencies are now fixed + (affects only unusual environments). + `#4043 `_ + +* ``pybind11::detail::get_internals()`` is now resilient to in-flight Python + exceptions. + `#3981 `_ + +* Arrays with a dimension of size 0 are now properly converted to dynamic Eigen + matrices (more common in NumPy 1.23). + `#4038 `_ + +* Avoid catching unrelated errors when importing NumPy. + `#3974 `_ + +Performance and style: + +* Added an accessor overload of ``(object &&key)`` to reference steal the + object when using python types as keys. This prevents unnecessary reference + count overhead for attr, dictionary, tuple, and sequence look ups. Added + additional regression tests. Fixed a performance bug the caused accessor + assignments to potentially perform unnecessary copies. + `#3970 `_ + +* Perfect forward all args of ``make_iterator``. + `#3980 `_ + +* Avoid potential bug in pycapsule destructor by adding an ``error_guard`` to + one of the dtors. + `#3958 `_ + +* Optimize dictionary access in ``strip_padding`` for numpy. + `#3994 `_ + +* ``stl_bind.h`` bindings now take slice args as a const-ref. + `#3852 `_ + +* Made slice constructor more consistent, and improve performance of some + casters by allowing reference stealing. + `#3845 `_ + +* Change numpy dtype from_args method to use const ref. + `#3878 `_ + +* Follow rule of three to ensure ``PyErr_Restore`` is called only once. + `#3872 `_ + +* Added missing perfect forwarding for ``make_iterator`` functions. + `#3860 `_ + +* Optimize c++ to python function casting by using the rvalue caster. + `#3966 `_ + +* Optimize Eigen sparse matrix casting by removing unnecessary temporary. + `#4064 `_ + +* Avoid potential implicit copy/assignment constructors causing double free in + ``strdup_gaurd``. + `#3905 `_ + +* Enable clang-tidy checks ``misc-definitions-in-headers``, + ``modernize-loop-convert``, and ``modernize-use-nullptr``. + `#3881 `_ + `#3988 `_ + + +Build system improvements: + +* CMake: Fix file extension on Windows with cp36 and cp37 using FindPython. + `#3919 `_ + +* CMake: Support multiple Python targets (such as on vcpkg). + `#3948 `_ + +* CMake: Fix issue with NVCC on Windows. + `#3947 `_ + +* CMake: Drop the bitness check on cross compiles (like targeting WebAssembly + via Emscripten). + `#3959 `_ + +* Add MSVC builds in debug mode to CI. + `#3784 `_ + +* MSVC 2022 C++20 coverage was added to GitHub Actions, including Eigen. + `#3732 `_, + `#3741 `_ + + +Backend and tidying up: + +* New theme for the documentation. + `#3109 `_ + +* Remove idioms in code comments. Use more inclusive language. + `#3809 `_ + +* ``#include `` was removed from the ``pybind11/stl.h`` header. Your + project may break if it has a transitive dependency on this include. The fix + is to "Include What You Use". + `#3928 `_ + +* Avoid ``setup.py `` usage in internal tests. + `#3734 `_ + + +Version 2.9.2 (Mar 29, 2022) +---------------------------- + +Changes: + +* Enum now has an ``__index__`` method on Python <3.8 too. + `#3700 `_ + +* Local internals are now cleared after finalizing the interpreter. + `#3744 `_ + +Bug fixes: + +* Better support for Python 3.11 alphas. + `#3694 `_ + +* ``PYBIND11_TYPE_CASTER`` now uses fully qualified symbols, so it can be used + outside of ``pybind11::detail``. + `#3758 `_ + +* Some fixes for PyPy 3.9. + `#3768 `_ + +* Fixed a potential memleak in PyPy in ``get_type_override``. + `#3774 `_ + +* Fix usage of ``VISIBILITY_INLINES_HIDDEN``. + `#3721 `_ + + +Build system improvements: + +* Uses ``sysconfig`` module to determine installation locations on Python >= + 3.10, instead of ``distutils`` which has been deprecated. + `#3764 `_ + +* Support Catch 2.13.5+ (supporting GLIBC 2.34+). + `#3679 `_ + +* Fix test failures with numpy 1.22 by ignoring whitespace when comparing + ``str()`` of dtypes. + `#3682 `_ + + +Backend and tidying up: + +* clang-tidy: added ``readability-qualified-auto``, + ``readability-braces-around-statements``, + ``cppcoreguidelines-prefer-member-initializer``, + ``clang-analyzer-optin.performance.Padding``, + ``cppcoreguidelines-pro-type-static-cast-downcast``, and + ``readability-inconsistent-declaration-parameter-name``. + `#3702 `_, + `#3699 `_, + `#3716 `_, + `#3709 `_ + +* clang-format was added to the pre-commit actions, and the entire code base + automatically reformatted (after several iterations preparing for this leap). + `#3713 `_ + + +Version 2.9.1 (Feb 2, 2022) +--------------------------- + +Changes: + +* If possible, attach Python exception with ``py::raise_from`` to ``TypeError`` + when casting from C++ to Python. This will give additional info if Python + exceptions occur in the caster. Adds a test case of trying to convert a set + from C++ to Python when the hash function is not defined in Python. + `#3605 `_ + +* Add a mapping of C++11 nested exceptions to their Python exception + equivalent using ``py::raise_from``. This attaches the nested exceptions in + Python using the ``__cause__`` field. + `#3608 `_ + +* Propagate Python exception traceback using ``raise_from`` if a pybind11 + function runs out of overloads. + `#3671 `_ + +* ``py::multiple_inheritance`` is now only needed when C++ bases are hidden + from pybind11. + `#3650 `_ and + `#3659 `_ + + +Bug fixes: + +* Remove a boolean cast in ``numpy.h`` that causes MSVC C4800 warnings when + compiling against Python 3.10 or newer. + `#3669 `_ + +* Render ``py::bool_`` and ``py::float_`` as ``bool`` and ``float`` + respectively. + `#3622 `_ + +Build system improvements: + +* Fix CMake extension suffix computation on Python 3.10+. + `#3663 `_ + +* Allow ``CMAKE_ARGS`` to override CMake args in pybind11's own ``setup.py``. + `#3577 `_ + +* Remove a few deprecated c-headers. + `#3610 `_ + +* More uniform handling of test targets. + `#3590 `_ + +* Add clang-tidy readability check to catch potentially swapped function args. + `#3611 `_ + + +Version 2.9.0 (Dec 28, 2021) +---------------------------- + +This is the last version to support Python 2.7 and 3.5. + +New Features: + +* Allow ``py::args`` to be followed by other arguments; the remaining arguments + are implicitly keyword-only, as if a ``py::kw_only{}`` annotation had been + used. + `#3402 `_ + +Changes: + +* Make str/bytes/memoryview more interoperable with ``std::string_view``. + `#3521 `_ + +* Replace ``_`` with ``const_name`` in internals, avoid defining ``pybind::_`` + if ``_`` defined as macro (common gettext usage) + `#3423 `_ + + +Bug fixes: + +* Fix a rare warning about extra copy in an Eigen constructor. + `#3486 `_ + +* Fix caching of the C++ overrides. + `#3465 `_ + +* Add missing ``std::forward`` calls to some ``cpp_function`` overloads. + `#3443 `_ + +* Support PyPy 7.3.7 and the PyPy3.8 beta. Test python-3.11 on PRs with the + ``python dev`` label. + `#3419 `_ + +* Replace usage of deprecated ``Eigen::MappedSparseMatrix`` with + ``Eigen::Map>`` for Eigen 3.3+. + `#3499 `_ + +* Tweaks to support Microsoft Visual Studio 2022. + `#3497 `_ + +Build system improvements: + +* Nicer CMake printout and IDE organisation for pybind11's own tests. + `#3479 `_ + +* CMake: report version type as part of the version string to avoid a spurious + space in the package status message. + `#3472 `_ + +* Flags starting with ``-g`` in ``$CFLAGS`` and ``$CPPFLAGS`` are no longer + overridden by ``.Pybind11Extension``. + `#3436 `_ + +* Ensure ThreadPool is closed in ``setup_helpers``. + `#3548 `_ + +* Avoid LTS on ``mips64`` and ``ppc64le`` (reported broken). + `#3557 `_ + + +v2.8.1 (Oct 27, 2021) +--------------------- + +Changes and additions: + +* The simple namespace creation shortcut added in 2.8.0 was deprecated due to + usage of CPython internal API, and will be removed soon. Use + ``py::module_::import("types").attr("SimpleNamespace")``. + `#3374 `_ + +* Add C++ Exception type to throw and catch ``AttributeError``. Useful for + defining custom ``__setattr__`` and ``__getattr__`` methods. + `#3387 `_ + +Fixes: + +* Fixed the potential for dangling references when using properties with + ``std::optional`` types. + `#3376 `_ + +* Modernize usage of ``PyCodeObject`` on Python 3.9+ (moving toward support for + Python 3.11a1) + `#3368 `_ + +* A long-standing bug in ``eigen.h`` was fixed (originally PR #3343). The bug + was unmasked by newly added ``static_assert``'s in the Eigen 3.4.0 release. + `#3352 `_ + +* Support multiple raw inclusion of CMake helper files (Conan.io does this for + multi-config generators). + `#3420 `_ + +* Fix harmless warning on upcoming CMake 3.22. + `#3368 `_ + +* Fix 2.8.0 regression with MSVC 2017 + C++17 mode + Python 3. + `#3407 `_ + +* Fix 2.8.0 regression that caused undefined behavior (typically + segfaults) in ``make_key_iterator``/``make_value_iterator`` if dereferencing + the iterator returned a temporary value instead of a reference. + `#3348 `_ + + +v2.8.0 (Oct 4, 2021) +-------------------- + +New features: + +* Added ``py::raise_from`` to enable chaining exceptions. + `#3215 `_ + +* Allow exception translators to be optionally registered local to a module + instead of applying globally across all pybind11 modules. Use + ``register_local_exception_translator(ExceptionTranslator&& translator)`` + instead of ``register_exception_translator(ExceptionTranslator&& + translator)`` to keep your exception remapping code local to the module. + `#2650 `_ + +* Add ``make_simple_namespace`` function for instantiating Python + ``SimpleNamespace`` objects. **Deprecated in 2.8.1.** + `#2840 `_ + +* ``pybind11::scoped_interpreter`` and ``initialize_interpreter`` have new + arguments to allow ``sys.argv`` initialization. + `#2341 `_ + +* Allow Python builtins to be used as callbacks in CPython. + `#1413 `_ + +* Added ``view`` to view arrays with a different datatype. + `#987 `_ + +* Implemented ``reshape`` on arrays. + `#984 `_ + +* Enable defining custom ``__new__`` methods on classes by fixing bug + preventing overriding methods if they have non-pybind11 siblings. + `#3265 `_ + +* Add ``make_value_iterator()``, and fix ``make_key_iterator()`` to return + references instead of copies. + `#3293 `_ + +* Improve the classes generated by ``bind_map``: `#3310 `_ + + * Change ``.items`` from an iterator to a dictionary view. + * Add ``.keys`` and ``.values`` (both dictionary views). + * Allow ``__contains__`` to take any object. + +* ``pybind11::custom_type_setup`` was added, for customizing the + ``PyHeapTypeObject`` corresponding to a class, which may be useful for + enabling garbage collection support, among other things. + `#3287 `_ + + +Changes: + +* Set ``__file__`` constant when running ``eval_file`` in an embedded interpreter. + `#3233 `_ + +* Python objects and (C++17) ``std::optional`` now accepted in ``py::slice`` + constructor. + `#1101 `_ + +* The pybind11 proxy types ``str``, ``bytes``, ``bytearray``, ``tuple``, + ``list`` now consistently support passing ``ssize_t`` values for sizes and + indexes. Previously, only ``size_t`` was accepted in several interfaces. + `#3219 `_ + +* Avoid evaluating ``PYBIND11_TLS_REPLACE_VALUE`` arguments more than once. + `#3290 `_ + +Fixes: + +* Bug fix: enum value's ``__int__`` returning non-int when underlying type is + bool or of char type. + `#1334 `_ + +* Fixes bug in setting error state in Capsule's pointer methods. + `#3261 `_ + +* A long-standing memory leak in ``py::cpp_function::initialize`` was fixed. + `#3229 `_ + +* Fixes thread safety for some ``pybind11::type_caster`` which require lifetime + extension, such as for ``std::string_view``. + `#3237 `_ + +* Restore compatibility with gcc 4.8.4 as distributed by ubuntu-trusty, linuxmint-17. + `#3270 `_ + + +Build system improvements: + +* Fix regression in CMake Python package config: improper use of absolute path. + `#3144 `_ + +* Cached Python version information could become stale when CMake was re-run + with a different Python version. The build system now detects this and + updates this information. + `#3299 `_ + +* Specified UTF8-encoding in setup.py calls of open(). + `#3137 `_ + +* Fix a harmless warning from CMake 3.21 with the classic Python discovery. + `#3220 `_ + +* Eigen repo and version can now be specified as cmake options. + `#3324 `_ + + +Backend and tidying up: + +* Reduced thread-local storage required for keeping alive temporary data for + type conversion to one key per ABI version, rather than one key per extension + module. This makes the total thread-local storage required by pybind11 2 + keys per ABI version. + `#3275 `_ + +* Optimize NumPy array construction with additional moves. + `#3183 `_ + +* Conversion to ``std::string`` and ``std::string_view`` now avoids making an + extra copy of the data on Python >= 3.3. + `#3257 `_ + +* Remove const modifier from certain C++ methods on Python collections + (``list``, ``set``, ``dict``) such as (``clear()``, ``append()``, + ``insert()``, etc...) and annotated them with ``py-non-const``. + +* Enable readability ``clang-tidy-const-return`` and remove useless consts. + `#3254 `_ + `#3194 `_ + +* The clang-tidy ``google-explicit-constructor`` option was enabled. + `#3250 `_ + +* Mark a pytype move constructor as noexcept (perf). + `#3236 `_ + +* Enable clang-tidy check to guard against inheritance slicing. + `#3210 `_ + +* Legacy warning suppression pragma were removed from eigen.h. On Unix + platforms, please use -isystem for Eigen include directories, to suppress + compiler warnings originating from Eigen headers. Note that CMake does this + by default. No adjustments are needed for Windows. + `#3198 `_ + +* Format pybind11 with isort consistent ordering of imports + `#3195 `_ + +* The warnings-suppression "pragma clamp" at the top/bottom of pybind11 was + removed, clearing the path to refactoring and IWYU cleanup. + `#3186 `_ + +* Enable most bugprone checks in clang-tidy and fix the found potential bugs + and poor coding styles. + `#3166 `_ + +* Add ``clang-tidy-readability`` rules to make boolean casts explicit improving + code readability. Also enabled other misc and readability clang-tidy checks. + `#3148 `_ + +* Move object in ``.pop()`` for list. + `#3116 `_ + + + + +v2.7.1 (Aug 3, 2021) +--------------------- + +Minor missing functionality added: + +* Allow Python builtins to be used as callbacks in CPython. + `#1413 `_ + +Bug fixes: + +* Fix regression in CMake Python package config: improper use of absolute path. + `#3144 `_ + +* Fix Mingw64 and add to the CI testing matrix. + `#3132 `_ + +* Specified UTF8-encoding in setup.py calls of open(). + `#3137 `_ + +* Add clang-tidy-readability rules to make boolean casts explicit improving + code readability. Also enabled other misc and readability clang-tidy checks. + `#3148 `_ + +* Move object in ``.pop()`` for list. + `#3116 `_ + +Backend and tidying up: + +* Removed and fixed warning suppressions. + `#3127 `_ + `#3129 `_ + `#3135 `_ + `#3141 `_ + `#3142 `_ + `#3150 `_ + `#3152 `_ + `#3160 `_ + `#3161 `_ + + +v2.7.0 (Jul 16, 2021) +--------------------- + +New features: + +* Enable ``py::implicitly_convertible`` for + ``py::class_``-wrapped types. + `#3059 `_ + +* Allow function pointer extraction from overloaded functions. + `#2944 `_ + +* NumPy: added ``.char_()`` to type which gives the NumPy public ``char`` + result, which also distinguishes types by bit length (unlike ``.kind()``). + `#2864 `_ + +* Add ``pybind11::bytearray`` to manipulate ``bytearray`` similar to ``bytes``. + `#2799 `_ + +* ``pybind11/stl/filesystem.h`` registers a type caster that, on C++17/Python + 3.6+, converts ``std::filesystem::path`` to ``pathlib.Path`` and any + ``os.PathLike`` to ``std::filesystem::path``. + `#2730 `_ + +* A ``PYBIND11_VERSION_HEX`` define was added, similar to ``PY_VERSION_HEX``. + `#3120 `_ + + + +Changes: + +* ``py::str`` changed to exclusively hold ``PyUnicodeObject``. Previously + ``py::str`` could also hold ``bytes``, which is probably surprising, was + never documented, and can mask bugs (e.g. accidental use of ``py::str`` + instead of ``py::bytes``). + `#2409 `_ + +* Add a safety guard to ensure that the Python GIL is held when C++ calls back + into Python via ``object_api<>::operator()`` (e.g. ``py::function`` + ``__call__``). (This feature is available for Python 3.6+ only.) + `#2919 `_ + +* Catch a missing ``self`` argument in calls to ``__init__()``. + `#2914 `_ + +* Use ``std::string_view`` if available to avoid a copy when passing an object + to a ``std::ostream``. + `#3042 `_ + +* An important warning about thread safety was added to the ``iostream.h`` + documentation; attempts to make ``py::scoped_ostream_redirect`` thread safe + have been removed, as it was only partially effective. + `#2995 `_ + + +Fixes: + +* Performance: avoid unnecessary strlen calls. + `#3058 `_ + +* Fix auto-generated documentation string when using ``const T`` in + ``pyarray_t``. + `#3020 `_ + +* Unify error messages thrown by ``simple_collector``/``unpacking_collector``. + `#3013 `_ + +* ``pybind11::builtin_exception`` is now explicitly exported, which means the + types included/defined in different modules are identical, and exceptions + raised in different modules can be caught correctly. The documentation was + updated to explain that custom exceptions that are used across module + boundaries need to be explicitly exported as well. + `#2999 `_ + +* Fixed exception when printing UTF-8 to a ``scoped_ostream_redirect``. + `#2982 `_ + +* Pickle support enhancement: ``setstate`` implementation will attempt to + ``setattr`` ``__dict__`` only if the unpickled ``dict`` object is not empty, + to not force use of ``py::dynamic_attr()`` unnecessarily. + `#2972 `_ + +* Allow negative timedelta values to roundtrip. + `#2870 `_ + +* Fix unchecked errors could potentially swallow signals/other exceptions. + `#2863 `_ + +* Add null pointer check with ``std::localtime``. + `#2846 `_ + +* Fix the ``weakref`` constructor from ``py::object`` to create a new + ``weakref`` on conversion. + `#2832 `_ + +* Avoid relying on exceptions in C++17 when getting a ``shared_ptr`` holder + from a ``shared_from_this`` class. + `#2819 `_ + +* Allow the codec's exception to be raised instead of :code:`RuntimeError` when + casting from :code:`py::str` to :code:`std::string`. + `#2903 `_ + + +Build system improvements: + +* In ``setup_helpers.py``, test for platforms that have some multiprocessing + features but lack semaphores, which ``ParallelCompile`` requires. + `#3043 `_ + +* Fix ``pybind11_INCLUDE_DIR`` in case ``CMAKE_INSTALL_INCLUDEDIR`` is + absolute. + `#3005 `_ + +* Fix bug not respecting ``WITH_SOABI`` or ``WITHOUT_SOABI`` to CMake. + `#2938 `_ + +* Fix the default ``Pybind11Extension`` compilation flags with a Mingw64 python. + `#2921 `_ + +* Clang on Windows: do not pass ``/MP`` (ignored flag). + `#2824 `_ + +* ``pybind11.setup_helpers.intree_extensions`` can be used to generate + ``Pybind11Extension`` instances from cpp files placed in the Python package + source tree. + `#2831 `_ + +Backend and tidying up: + +* Enable clang-tidy performance, readability, and modernization checks + throughout the codebase to enforce best coding practices. + `#3046 `_, + `#3049 `_, + `#3051 `_, + `#3052 `_, + `#3080 `_, and + `#3094 `_ + + +* Checks for common misspellings were added to the pre-commit hooks. + `#3076 `_ + +* Changed ``Werror`` to stricter ``Werror-all`` for Intel compiler and fixed + minor issues. + `#2948 `_ + +* Fixed compilation with GCC < 5 when the user defines ``_GLIBCXX_USE_CXX11_ABI``. + `#2956 `_ + +* Added nox support for easier local testing and linting of contributions. + `#3101 `_ and + `#3121 `_ + +* Avoid RTD style issue with docutils 0.17+. + `#3119 `_ + +* Support pipx run, such as ``pipx run pybind11 --include`` for a quick compile. + `#3117 `_ + + + +v2.6.2 (Jan 26, 2021) +--------------------- + +Minor missing functionality added: + +* enum: add missing Enum.value property. + `#2739 `_ + +* Allow thread termination to be avoided during shutdown for CPython 3.7+ via + ``.disarm`` for ``gil_scoped_acquire``/``gil_scoped_release``. + `#2657 `_ + +Fixed or improved behavior in a few special cases: + +* Fix bug where the constructor of ``object`` subclasses would not throw on + being passed a Python object of the wrong type. + `#2701 `_ + +* The ``type_caster`` for integers does not convert Python objects with + ``__int__`` anymore with ``noconvert`` or during the first round of trying + overloads. + `#2698 `_ + +* When casting to a C++ integer, ``__index__`` is always called and not + considered as conversion, consistent with Python 3.8+. + `#2801 `_ + +Build improvements: + +* Setup helpers: ``extra_compile_args`` and ``extra_link_args`` automatically set by + Pybind11Extension are now prepended, which allows them to be overridden + by user-set ``extra_compile_args`` and ``extra_link_args``. + `#2808 `_ + +* Setup helpers: Don't trigger unused parameter warning. + `#2735 `_ + +* CMake: Support running with ``--warn-uninitialized`` active. + `#2806 `_ + +* CMake: Avoid error if included from two submodule directories. + `#2804 `_ + +* CMake: Fix ``STATIC`` / ``SHARED`` being ignored in FindPython mode. + `#2796 `_ + +* CMake: Respect the setting for ``CMAKE_CXX_VISIBILITY_PRESET`` if defined. + `#2793 `_ + +* CMake: Fix issue with FindPython2/FindPython3 not working with ``pybind11::embed``. + `#2662 `_ + +* CMake: mixing local and installed pybind11's would prioritize the installed + one over the local one (regression in 2.6.0). + `#2716 `_ + + +Bug fixes: + +* Fixed segfault in multithreaded environments when using + ``scoped_ostream_redirect``. + `#2675 `_ + +* Leave docstring unset when all docstring-related options are disabled, rather + than set an empty string. + `#2745 `_ + +* The module key in builtins that pybind11 uses to store its internals changed + from std::string to a python str type (more natural on Python 2, no change on + Python 3). + `#2814 `_ + +* Fixed assertion error related to unhandled (later overwritten) exception in + CPython 3.8 and 3.9 debug builds. + `#2685 `_ + +* Fix ``py::gil_scoped_acquire`` assert with CPython 3.9 debug build. + `#2683 `_ + +* Fix issue with a test failing on pytest 6.2. + `#2741 `_ + +Warning fixes: + +* Fix warning modifying constructor parameter 'flag' that shadows a field of + 'set_flag' ``[-Wshadow-field-in-constructor-modified]``. + `#2780 `_ + +* Suppressed some deprecation warnings about old-style + ``__init__``/``__setstate__`` in the tests. + `#2759 `_ + +Valgrind work: + +* Fix invalid access when calling a pybind11 ``__init__`` on a non-pybind11 + class instance. + `#2755 `_ + +* Fixed various minor memory leaks in pybind11's test suite. + `#2758 `_ + +* Resolved memory leak in cpp_function initialization when exceptions occurred. + `#2756 `_ + +* Added a Valgrind build, checking for leaks and memory-related UB, to CI. + `#2746 `_ + +Compiler support: + +* Intel compiler was not activating C++14 support due to a broken define. + `#2679 `_ + +* Support ICC and NVIDIA HPC SDK in C++17 mode. + `#2729 `_ + +* Support Intel OneAPI compiler (ICC 20.2) and add to CI. + `#2573 `_ + + + +v2.6.1 (Nov 11, 2020) +--------------------- + +* ``py::exec``, ``py::eval``, and ``py::eval_file`` now add the builtins module + as ``"__builtins__"`` to their ``globals`` argument, better matching ``exec`` + and ``eval`` in pure Python. + `#2616 `_ + +* ``setup_helpers`` will no longer set a minimum macOS version higher than the + current version. + `#2622 `_ + +* Allow deleting static properties. + `#2629 `_ + +* Seal a leak in ``def_buffer``, cleaning up the ``capture`` object after the + ``class_`` object goes out of scope. + `#2634 `_ + +* ``pybind11_INCLUDE_DIRS`` was incorrect, potentially causing a regression if + it was expected to include ``PYTHON_INCLUDE_DIRS`` (please use targets + instead). + `#2636 `_ + +* Added parameter names to the ``py::enum_`` constructor and methods, avoiding + ``arg0`` in the generated docstrings. + `#2637 `_ + +* Added ``needs_recompile`` optional function to the ``ParallelCompiler`` + helper, to allow a recompile to be skipped based on a user-defined function. + `#2643 `_ + + +v2.6.0 (Oct 21, 2020) +--------------------- + +See :ref:`upgrade-guide-2.6` for help upgrading to the new version. + +New features: + +* Keyword-only arguments supported in Python 2 or 3 with ``py::kw_only()``. + `#2100 `_ + +* Positional-only arguments supported in Python 2 or 3 with ``py::pos_only()``. + `#2459 `_ + +* ``py::is_final()`` class modifier to block subclassing (CPython only). + `#2151 `_ + +* Added ``py::prepend()``, allowing a function to be placed at the beginning of + the overload chain. + `#1131 `_ + +* Access to the type object now provided with ``py::type::of()`` and + ``py::type::of(h)``. + `#2364 `_ + +* Perfect forwarding support for methods. + `#2048 `_ + +* Added ``py::error_already_set::discard_as_unraisable()``. + `#2372 `_ + +* ``py::hash`` is now public. + `#2217 `_ + +* ``py::class_`` is now supported. Note that writing to one data + member of the union and reading another (type punning) is UB in C++. Thus + pybind11-bound enums should never be used for such conversions. + `#2320 `_. + +* Classes now check local scope when registering members, allowing a subclass + to have a member with the same name as a parent (such as an enum). + `#2335 `_ + +Code correctness features: + +* Error now thrown when ``__init__`` is forgotten on subclasses. + `#2152 `_ + +* Throw error if conversion to a pybind11 type if the Python object isn't a + valid instance of that type, such as ``py::bytes(o)`` when ``py::object o`` + isn't a bytes instance. + `#2349 `_ + +* Throw if conversion to ``str`` fails. + `#2477 `_ + + +API changes: + +* ``py::module`` was renamed ``py::module_`` to avoid issues with C++20 when + used unqualified, but an alias ``py::module`` is provided for backward + compatibility. + `#2489 `_ + +* Public constructors for ``py::module_`` have been deprecated; please use + ``pybind11::module_::create_extension_module`` if you were using the public + constructor (fairly rare after ``PYBIND11_MODULE`` was introduced). + `#2552 `_ + +* ``PYBIND11_OVERLOAD*`` macros and ``get_overload`` function replaced by + correctly-named ``PYBIND11_OVERRIDE*`` and ``get_override``, fixing + inconsistencies in the presence of a closing ``;`` in these macros. + ``get_type_overload`` is deprecated. + `#2325 `_ + +Packaging / building improvements: + +* The Python package was reworked to be more powerful and useful. + `#2433 `_ + + * :ref:`build-setuptools` is easier thanks to a new + ``pybind11.setup_helpers`` module, which provides utilities to use + setuptools with pybind11. It can be used via PEP 518, ``setup_requires``, + or by directly importing or copying ``setup_helpers.py`` into your project. + + * CMake configuration files are now included in the Python package. Use + ``pybind11.get_cmake_dir()`` or ``python -m pybind11 --cmakedir`` to get + the directory with the CMake configuration files, or include the + site-packages location in your ``CMAKE_MODULE_PATH``. Or you can use the + new ``pybind11[global]`` extra when you install ``pybind11``, which + installs the CMake files and headers into your base environment in the + standard location. + + * ``pybind11-config`` is another way to write ``python -m pybind11`` if you + have your PATH set up. + + * Added external typing support to the helper module, code from + ``import pybind11`` can now be type checked. + `#2588 `_ + +* Minimum CMake required increased to 3.4. + `#2338 `_ and + `#2370 `_ + + * Full integration with CMake's C++ standard system and compile features + replaces ``PYBIND11_CPP_STANDARD``. + + * Generated config file is now portable to different Python/compiler/CMake + versions. + + * Virtual environments prioritized if ``PYTHON_EXECUTABLE`` is not set + (``venv``, ``virtualenv``, and ``conda``) (similar to the new FindPython + mode). + + * Other CMake features now natively supported, like + ``CMAKE_INTERPROCEDURAL_OPTIMIZATION``, ``set(CMAKE_CXX_VISIBILITY_PRESET + hidden)``. + + * ``CUDA`` as a language is now supported. + + * Helper functions ``pybind11_strip``, ``pybind11_extension``, + ``pybind11_find_import`` added, see :doc:`cmake/index`. + + * Optional :ref:`find-python-mode` and :ref:`nopython-mode` with CMake. + `#2370 `_ + +* Uninstall target added. + `#2265 `_ and + `#2346 `_ + +* ``pybind11_add_module()`` now accepts an optional ``OPT_SIZE`` flag that + switches the binding target to size-based optimization if the global build + type can not always be fixed to ``MinSizeRel`` (except in debug mode, where + optimizations remain disabled). ``MinSizeRel`` or this flag reduces binary + size quite substantially (~25% on some platforms). + `#2463 `_ + +Smaller or developer focused features and fixes: + +* Moved ``mkdoc.py`` to a new repo, `pybind11-mkdoc`_. There are no longer + submodules in the main repo. + +* ``py::memoryview`` segfault fix and update, with new + ``py::memoryview::from_memory`` in Python 3, and documentation. + `#2223 `_ + +* Fix for ``buffer_info`` on Python 2. + `#2503 `_ + +* If ``__eq__`` defined but not ``__hash__``, ``__hash__`` is now set to + ``None``. + `#2291 `_ + +* ``py::ellipsis`` now also works on Python 2. + `#2360 `_ + +* Pointer to ``std::tuple`` & ``std::pair`` supported in cast. + `#2334 `_ + +* Small fixes in NumPy support. ``py::array`` now uses ``py::ssize_t`` as first + argument type. + `#2293 `_ + +* Added missing signature for ``py::array``. + `#2363 `_ + +* ``unchecked_mutable_reference`` has access to operator ``()`` and ``[]`` when + const. + `#2514 `_ + +* ``py::vectorize`` is now supported on functions that return void. + `#1969 `_ + +* ``py::capsule`` supports ``get_pointer`` and ``set_pointer``. + `#1131 `_ + +* Fix crash when different instances share the same pointer of the same type. + `#2252 `_ + +* Fix for ``py::len`` not clearing Python's error state when it fails and throws. + `#2575 `_ + +* Bugfixes related to more extensive testing, new GitHub Actions CI. + `#2321 `_ + +* Bug in timezone issue in Eastern hemisphere midnight fixed. + `#2438 `_ + +* ``std::chrono::time_point`` now works when the resolution is not the same as + the system. + `#2481 `_ + +* Bug fixed where ``py::array_t`` could accept arrays that did not match the + requested ordering. + `#2484 `_ + +* Avoid a segfault on some compilers when types are removed in Python. + `#2564 `_ + +* ``py::arg::none()`` is now also respected when passing keyword arguments. + `#2611 `_ + +* PyPy fixes, PyPy 7.3.x now supported, including PyPy3. (Known issue with + PyPy2 and Windows `#2596 `_). + `#2146 `_ + +* CPython 3.9.0 workaround for undefined behavior (macOS segfault). + `#2576 `_ + +* CPython 3.9 warning fixes. + `#2253 `_ + +* Improved C++20 support, now tested in CI. + `#2489 `_ + `#2599 `_ + +* Improved but still incomplete debug Python interpreter support. + `#2025 `_ + +* NVCC (CUDA 11) now supported and tested in CI. + `#2461 `_ + +* NVIDIA PGI compilers now supported and tested in CI. + `#2475 `_ + +* At least Intel 18 now explicitly required when compiling with Intel. + `#2577 `_ + +* Extensive style checking in CI, with `pre-commit`_ support. Code + modernization, checked by clang-tidy. + +* Expanded docs, including new main page, new installing section, and CMake + helpers page, along with over a dozen new sections on existing pages. + +* In GitHub, new docs for contributing and new issue templates. + +.. _pre-commit: https://pre-commit.com + +.. _pybind11-mkdoc: https://github.com/pybind/pybind11-mkdoc + +v2.5.0 (Mar 31, 2020) +----------------------------------------------------- + +* Use C++17 fold expressions in type casters, if available. This can + improve performance during overload resolution when functions have + multiple arguments. + `#2043 `_. + +* Changed include directory resolution in ``pybind11/__init__.py`` + and installation in ``setup.py``. This fixes a number of open issues + where pybind11 headers could not be found in certain environments. + `#1995 `_. + +* C++20 ``char8_t`` and ``u8string`` support. `#2026 + `_. + +* CMake: search for Python 3.9. `bb9c91 + `_. + +* Fixes for MSYS-based build environments. + `#2087 `_, + `#2053 `_. + +* STL bindings for ``std::vector<...>::clear``. `#2074 + `_. + +* Read-only flag for ``py::buffer``. `#1466 + `_. + +* Exception handling during module initialization. + `bf2b031 `_. + +* Support linking against a CPython debug build. + `#2025 `_. + +* Fixed issues involving the availability and use of aligned ``new`` and + ``delete``. `#1988 `_, + `759221 `_. + +* Fixed a resource leak upon interpreter shutdown. + `#2020 `_. + +* Fixed error handling in the boolean caster. + `#1976 `_. + +v2.4.3 (Oct 15, 2019) +----------------------------------------------------- + +* Adapt pybind11 to a C API convention change in Python 3.8. `#1950 + `_. + +v2.4.2 (Sep 21, 2019) +----------------------------------------------------- + +* Replaced usage of a C++14 only construct. `#1929 + `_. + +* Made an ifdef future-proof for Python >= 4. `f3109d + `_. + +v2.4.1 (Sep 20, 2019) +----------------------------------------------------- + +* Fixed a problem involving implicit conversion from enumerations to integers + on Python 3.8. `#1780 `_. + +v2.4.0 (Sep 19, 2019) +----------------------------------------------------- + +* Try harder to keep pybind11-internal data structures separate when there + are potential ABI incompatibilities. Fixes crashes that occurred when loading + multiple pybind11 extensions that were e.g. compiled by GCC (libstdc++) + and Clang (libc++). + `#1588 `_ and + `c9f5a `_. + +* Added support for ``__await__``, ``__aiter__``, and ``__anext__`` protocols. + `#1842 `_. + +* ``pybind11_add_module()``: don't strip symbols when compiling in + ``RelWithDebInfo`` mode. `#1980 + `_. + +* ``enum_``: Reproduce Python behavior when comparing against invalid values + (e.g. ``None``, strings, etc.). Add back support for ``__invert__()``. + `#1912 `_, + `#1907 `_. + +* List insertion operation for ``py::list``. + Added ``.empty()`` to all collection types. + Added ``py::set::contains()`` and ``py::dict::contains()``. + `#1887 `_, + `#1884 `_, + `#1888 `_. + +* ``py::details::overload_cast_impl`` is available in C++11 mode, can be used + like ``overload_cast`` with an additional set of parentheses. + `#1581 `_. + +* Fixed ``get_include()`` on Conda. + `#1877 `_. + +* ``stl_bind.h``: negative indexing support. + `#1882 `_. + +* Minor CMake fix to add MinGW compatibility. + `#1851 `_. + +* GIL-related fixes. + `#1836 `_, + `8b90b `_. + +* Other very minor/subtle fixes and improvements. + `#1329 `_, + `#1910 `_, + `#1863 `_, + `#1847 `_, + `#1890 `_, + `#1860 `_, + `#1848 `_, + `#1821 `_, + `#1837 `_, + `#1833 `_, + `#1748 `_, + `#1852 `_. + +v2.3.0 (June 11, 2019) +----------------------------------------------------- + +* Significantly reduced module binary size (10-20%) when compiled in C++11 mode + with GCC/Clang, or in any mode with MSVC. Function signatures are now always + precomputed at compile time (this was previously only available in C++14 mode + for non-MSVC compilers). + `#934 `_. + +* Add basic support for tag-based static polymorphism, where classes + provide a method to returns the desired type of an instance. + `#1326 `_. + +* Python type wrappers (``py::handle``, ``py::object``, etc.) + now support map Python's number protocol onto C++ arithmetic + operators such as ``operator+``, ``operator/=``, etc. + `#1511 `_. + +* A number of improvements related to enumerations: + + 1. The ``enum_`` implementation was rewritten from scratch to reduce + code bloat. Rather than instantiating a full implementation for each + enumeration, most code is now contained in a generic base class. + `#1511 `_. + + 2. The ``value()`` method of ``py::enum_`` now accepts an optional + docstring that will be shown in the documentation of the associated + enumeration. `#1160 `_. + + 3. check for already existing enum value and throw an error if present. + `#1453 `_. + +* Support for over-aligned type allocation via C++17's aligned ``new`` + statement. `#1582 `_. + +* Added ``py::ellipsis()`` method for slicing of multidimensional NumPy arrays + `#1502 `_. + +* Numerous Improvements to the ``mkdoc.py`` script for extracting documentation + from C++ header files. + `#1788 `_. + +* ``pybind11_add_module()``: allow including Python as a ``SYSTEM`` include path. + `#1416 `_. + +* ``pybind11/stl.h`` does not convert strings to ``vector`` anymore. + `#1258 `_. + +* Mark static methods as such to fix auto-generated Sphinx documentation. + `#1732 `_. + +* Re-throw forced unwind exceptions (e.g. during pthread termination). + `#1208 `_. + +* Added ``__contains__`` method to the bindings of maps (``std::map``, + ``std::unordered_map``). + `#1767 `_. + +* Improvements to ``gil_scoped_acquire``. + `#1211 `_. + +* Type caster support for ``std::deque``. + `#1609 `_. + +* Support for ``std::unique_ptr`` holders, whose deleters differ between a base and derived + class. `#1353 `_. + +* Construction of STL array/vector-like data structures from + iterators. Added an ``extend()`` operation. + `#1709 `_, + +* CMake build system improvements for projects that include non-C++ + files (e.g. plain C, CUDA) in ``pybind11_add_module`` et al. + `#1678 `_. + +* Fixed asynchronous invocation and deallocation of Python functions + wrapped in ``std::function``. + `#1595 `_. + +* Fixes regarding return value policy propagation in STL type casters. + `#1603 `_. + +* Fixed scoped enum comparisons. + `#1571 `_. + +* Fixed iostream redirection for code that releases the GIL. + `#1368 `_, + +* A number of CI-related fixes. + `#1757 `_, + `#1744 `_, + `#1670 `_. + +v2.2.4 (September 11, 2018) +----------------------------------------------------- + +* Use new Python 3.7 Thread Specific Storage (TSS) implementation if available. + `#1454 `_, + `#1517 `_. + +* Fixes for newer MSVC versions and C++17 mode. + `#1347 `_, + `#1462 `_. + +* Propagate return value policies to type-specific casters + when casting STL containers. + `#1455 `_. + +* Allow ostream-redirection of more than 1024 characters. + `#1479 `_. + +* Set ``Py_DEBUG`` define when compiling against a debug Python build. + `#1438 `_. + +* Untangle integer logic in number type caster to work for custom + types that may only be castable to a restricted set of builtin types. + `#1442 `_. + +* CMake build system: Remember Python version in cache file. + `#1434 `_. + +* Fix for custom smart pointers: use ``std::addressof`` to obtain holder + address instead of ``operator&``. + `#1435 `_. + +* Properly report exceptions thrown during module initialization. + `#1362 `_. + +* Fixed a segmentation fault when creating empty-shaped NumPy array. + `#1371 `_. + +* The version of Intel C++ compiler must be >= 2017, and this is now checked by + the header files. `#1363 `_. + +* A few minor typo fixes and improvements to the test suite, and + patches that silence compiler warnings. + +* Vectors now support construction from generators, as well as ``extend()`` from a + list or generator. + `#1496 `_. + + +v2.2.3 (April 29, 2018) +----------------------------------------------------- + +* The pybind11 header location detection was replaced by a new implementation + that no longer depends on ``pip`` internals (the recently released ``pip`` + 10 has restricted access to this API). + `#1190 `_. + +* Small adjustment to an implementation detail to work around a compiler segmentation fault in Clang 3.3/3.4. + `#1350 `_. + +* The minimal supported version of the Intel compiler was >= 17.0 since + pybind11 v2.1. This check is now explicit, and a compile-time error is raised + if the compiler meet the requirement. + `#1363 `_. + +* Fixed an endianness-related fault in the test suite. + `#1287 `_. + +v2.2.2 (February 7, 2018) +----------------------------------------------------- + +* Fixed a segfault when combining embedded interpreter + shutdown/reinitialization with external loaded pybind11 modules. + `#1092 `_. + +* Eigen support: fixed a bug where Nx1/1xN numpy inputs couldn't be passed as + arguments to Eigen vectors (which for Eigen are simply compile-time fixed + Nx1/1xN matrices). + `#1106 `_. + +* Clarified to license by moving the licensing of contributions from + ``LICENSE`` into ``CONTRIBUTING.md``: the licensing of contributions is not + actually part of the software license as distributed. This isn't meant to be + a substantial change in the licensing of the project, but addresses concerns + that the clause made the license non-standard. + `#1109 `_. + +* Fixed a regression introduced in 2.1 that broke binding functions with lvalue + character literal arguments. + `#1128 `_. + +* MSVC: fix for compilation failures under /permissive-, and added the flag to + the appveyor test suite. + `#1155 `_. + +* Fixed ``__qualname__`` generation, and in turn, fixes how class names + (especially nested class names) are shown in generated docstrings. + `#1171 `_. + +* Updated the FAQ with a suggested project citation reference. + `#1189 `_. + +* Added fixes for deprecation warnings when compiled under C++17 with + ``-Wdeprecated`` turned on, and add ``-Wdeprecated`` to the test suite + compilation flags. + `#1191 `_. + +* Fixed outdated PyPI URLs in ``setup.py``. + `#1213 `_. + +* Fixed a refcount leak for arguments that end up in a ``py::args`` argument + for functions with both fixed positional and ``py::args`` arguments. + `#1216 `_. + +* Fixed a potential segfault resulting from possible premature destruction of + ``py::args``/``py::kwargs`` arguments with overloaded functions. + `#1223 `_. + +* Fixed ``del map[item]`` for a ``stl_bind.h`` bound stl map. + `#1229 `_. + +* Fixed a regression from v2.1.x where the aggregate initialization could + unintentionally end up at a constructor taking a templated + ``std::initializer_list`` argument. + `#1249 `_. + +* Fixed an issue where calling a function with a keep_alive policy on the same + nurse/patient pair would cause the internal patient storage to needlessly + grow (unboundedly, if the nurse is long-lived). + `#1251 `_. + +* Various other minor fixes. + +v2.2.1 (September 14, 2017) +----------------------------------------------------- + +* Added ``py::module_::reload()`` member function for reloading a module. + `#1040 `_. + +* Fixed a reference leak in the number converter. + `#1078 `_. + +* Fixed compilation with Clang on host GCC < 5 (old libstdc++ which isn't fully + C++11 compliant). `#1062 `_. + +* Fixed a regression where the automatic ``std::vector`` caster would + fail to compile. The same fix also applies to any container which returns + element proxies instead of references. + `#1053 `_. + +* Fixed a regression where the ``py::keep_alive`` policy could not be applied + to constructors. `#1065 `_. + +* Fixed a nullptr dereference when loading a ``py::module_local`` type + that's only registered in an external module. + `#1058 `_. + +* Fixed implicit conversion of accessors to types derived from ``py::object``. + `#1076 `_. + +* The ``name`` in ``PYBIND11_MODULE(name, variable)`` can now be a macro. + `#1082 `_. + +* Relaxed overly strict ``py::pickle()`` check for matching get and set types. + `#1064 `_. + +* Conversion errors now try to be more informative when it's likely that + a missing header is the cause (e.g. forgetting ````). + `#1077 `_. + +v2.2.0 (August 31, 2017) +----------------------------------------------------- + +* Support for embedding the Python interpreter. See the + :doc:`documentation page ` for a + full overview of the new features. + `#774 `_, + `#889 `_, + `#892 `_, + `#920 `_. + + .. code-block:: cpp + + #include + namespace py = pybind11; + + int main() { + py::scoped_interpreter guard{}; // start the interpreter and keep it alive + + py::print("Hello, World!"); // use the Python API + } + +* Support for inheriting from multiple C++ bases in Python. + `#693 `_. + + .. code-block:: python + + from cpp_module import CppBase1, CppBase2 + + + class PyDerived(CppBase1, CppBase2): + def __init__(self): + CppBase1.__init__(self) # C++ bases must be initialized explicitly + CppBase2.__init__(self) + +* ``PYBIND11_MODULE`` is now the preferred way to create module entry points. + ``PYBIND11_PLUGIN`` is deprecated. See :ref:`macros` for details. + `#879 `_. + + .. code-block:: cpp + + // new + PYBIND11_MODULE(example, m) { + m.def("add", [](int a, int b) { return a + b; }); + } + + // old + PYBIND11_PLUGIN(example) { + py::module m("example"); + m.def("add", [](int a, int b) { return a + b; }); + return m.ptr(); + } + +* pybind11's headers and build system now more strictly enforce hidden symbol + visibility for extension modules. This should be seamless for most users, + but see the :doc:`upgrade` if you use a custom build system. + `#995 `_. + +* Support for ``py::module_local`` types which allow multiple modules to + export the same C++ types without conflicts. This is useful for opaque + types like ``std::vector``. ``py::bind_vector`` and ``py::bind_map`` + now default to ``py::module_local`` if their elements are builtins or + local types. See :ref:`module_local` for details. + `#949 `_, + `#981 `_, + `#995 `_, + `#997 `_. + +* Custom constructors can now be added very easily using lambdas or factory + functions which return a class instance by value, pointer or holder. This + supersedes the old placement-new ``__init__`` technique. + See :ref:`custom_constructors` for details. + `#805 `_, + `#1014 `_. + + .. code-block:: cpp + + struct Example { + Example(std::string); + }; + + py::class_(m, "Example") + .def(py::init()) // existing constructor + .def(py::init([](int n) { // custom constructor + return std::make_unique(std::to_string(n)); + })); + +* Similarly to custom constructors, pickling support functions are now bound + using the ``py::pickle()`` adaptor which improves type safety. See the + :doc:`upgrade` and :ref:`pickling` for details. + `#1038 `_. + +* Builtin support for converting C++17 standard library types and general + conversion improvements: + + 1. C++17 ``std::variant`` is supported right out of the box. C++11/14 + equivalents (e.g. ``boost::variant``) can also be added with a simple + user-defined specialization. See :ref:`cpp17_container_casters` for details. + `#811 `_, + `#845 `_, + `#989 `_. + + 2. Out-of-the-box support for C++17 ``std::string_view``. + `#906 `_. + + 3. Improved compatibility of the builtin ``optional`` converter. + `#874 `_. + + 4. The ``bool`` converter now accepts ``numpy.bool_`` and types which + define ``__bool__`` (Python 3.x) or ``__nonzero__`` (Python 2.7). + `#925 `_. + + 5. C++-to-Python casters are now more efficient and move elements out + of rvalue containers whenever possible. + `#851 `_, + `#936 `_, + `#938 `_. + + 6. Fixed ``bytes`` to ``std::string/char*`` conversion on Python 3. + `#817 `_. + + 7. Fixed lifetime of temporary C++ objects created in Python-to-C++ conversions. + `#924 `_. + +* Scope guard call policy for RAII types, e.g. ``py::call_guard()``, + ``py::call_guard()``. See :ref:`call_policies` for details. + `#740 `_. + +* Utility for redirecting C++ streams to Python (e.g. ``std::cout`` -> + ``sys.stdout``). Scope guard ``py::scoped_ostream_redirect`` in C++ and + a context manager in Python. See :ref:`ostream_redirect`. + `#1009 `_. + +* Improved handling of types and exceptions across module boundaries. + `#915 `_, + `#951 `_, + `#995 `_. + +* Fixed destruction order of ``py::keep_alive`` nurse/patient objects + in reference cycles. + `#856 `_. + +* NumPy and buffer protocol related improvements: + + 1. Support for negative strides in Python buffer objects/numpy arrays. This + required changing integers from unsigned to signed for the related C++ APIs. + Note: If you have compiler warnings enabled, you may notice some new conversion + warnings after upgrading. These can be resolved with ``static_cast``. + `#782 `_. + + 2. Support ``std::complex`` and arrays inside ``PYBIND11_NUMPY_DTYPE``. + `#831 `_, + `#832 `_. + + 3. Support for constructing ``py::buffer_info`` and ``py::arrays`` using + arbitrary containers or iterators instead of requiring a ``std::vector``. + `#788 `_, + `#822 `_, + `#860 `_. + + 4. Explicitly check numpy version and require >= 1.7.0. + `#819 `_. + +* Support for allowing/prohibiting ``None`` for specific arguments and improved + ``None`` overload resolution order. See :ref:`none_arguments` for details. + `#843 `_. + `#859 `_. + +* Added ``py::exec()`` as a shortcut for ``py::eval()`` + and support for C++11 raw string literals as input. See :ref:`eval`. + `#766 `_, + `#827 `_. + +* ``py::vectorize()`` ignores non-vectorizable arguments and supports + member functions. + `#762 `_. + +* Support for bound methods as callbacks (``pybind11/functional.h``). + `#815 `_. + +* Allow aliasing pybind11 methods: ``cls.attr("foo") = cls.attr("bar")``. + `#802 `_. + +* Don't allow mixed static/non-static overloads. + `#804 `_. + +* Fixed overriding static properties in derived classes. + `#784 `_. + +* Added support for write only properties. + `#1144 `_. + +* Improved deduction of member functions of a derived class when its bases + aren't registered with pybind11. + `#855 `_. + + .. code-block:: cpp + + struct Base { + int foo() { return 42; } + } + + struct Derived : Base {} + + // Now works, but previously required also binding `Base` + py::class_(m, "Derived") + .def("foo", &Derived::foo); // function is actually from `Base` + +* The implementation of ``py::init<>`` now uses C++11 brace initialization + syntax to construct instances, which permits binding implicit constructors of + aggregate types. `#1015 `_. + + .. code-block:: cpp + + struct Aggregate { + int a; + std::string b; + }; + + py::class_(m, "Aggregate") + .def(py::init()); + +* Fixed issues with multiple inheritance with offset base/derived pointers. + `#812 `_, + `#866 `_, + `#960 `_. + +* Fixed reference leak of type objects. + `#1030 `_. + +* Improved support for the ``/std:c++14`` and ``/std:c++latest`` modes + on MSVC 2017. + `#841 `_, + `#999 `_. + +* Fixed detection of private operator new on MSVC. + `#893 `_, + `#918 `_. + +* Intel C++ compiler compatibility fixes. + `#937 `_. + +* Fixed implicit conversion of ``py::enum_`` to integer types on Python 2.7. + `#821 `_. + +* Added ``py::hash`` to fetch the hash value of Python objects, and + ``.def(hash(py::self))`` to provide the C++ ``std::hash`` as the Python + ``__hash__`` method. + `#1034 `_. + +* Fixed ``__truediv__`` on Python 2 and ``__itruediv__`` on Python 3. + `#867 `_. + +* ``py::capsule`` objects now support the ``name`` attribute. This is useful + for interfacing with ``scipy.LowLevelCallable``. + `#902 `_. + +* Fixed ``py::make_iterator``'s ``__next__()`` for past-the-end calls. + `#897 `_. + +* Added ``error_already_set::matches()`` for checking Python exceptions. + `#772 `_. + +* Deprecated ``py::error_already_set::clear()``. It's no longer needed + following a simplification of the ``py::error_already_set`` class. + `#954 `_. + +* Deprecated ``py::handle::operator==()`` in favor of ``py::handle::is()`` + `#825 `_. + +* Deprecated ``py::object::borrowed``/``py::object::stolen``. + Use ``py::object::borrowed_t{}``/``py::object::stolen_t{}`` instead. + `#771 `_. + +* Changed internal data structure versioning to avoid conflicts between + modules compiled with different revisions of pybind11. + `#1012 `_. + +* Additional compile-time and run-time error checking and more informative messages. + `#786 `_, + `#794 `_, + `#803 `_. + +* Various minor improvements and fixes. + `#764 `_, + `#791 `_, + `#795 `_, + `#840 `_, + `#844 `_, + `#846 `_, + `#849 `_, + `#858 `_, + `#862 `_, + `#871 `_, + `#872 `_, + `#881 `_, + `#888 `_, + `#899 `_, + `#928 `_, + `#931 `_, + `#944 `_, + `#950 `_, + `#952 `_, + `#962 `_, + `#965 `_, + `#970 `_, + `#978 `_, + `#979 `_, + `#986 `_, + `#1020 `_, + `#1027 `_, + `#1037 `_. + +* Testing improvements. + `#798 `_, + `#882 `_, + `#898 `_, + `#900 `_, + `#921 `_, + `#923 `_, + `#963 `_. + +v2.1.1 (April 7, 2017) +----------------------------------------------------- + +* Fixed minimum version requirement for MSVC 2015u3 + `#773 `_. + +v2.1.0 (March 22, 2017) +----------------------------------------------------- + +* pybind11 now performs function overload resolution in two phases. The first + phase only considers exact type matches, while the second allows for implicit + conversions to take place. A special ``noconvert()`` syntax can be used to + completely disable implicit conversions for specific arguments. + `#643 `_, + `#634 `_, + `#650 `_. + +* Fixed a regression where static properties no longer worked with classes + using multiple inheritance. The ``py::metaclass`` attribute is no longer + necessary (and deprecated as of this release) when binding classes with + static properties. + `#679 `_, + +* Classes bound using ``pybind11`` can now use custom metaclasses. + `#679 `_, + +* ``py::args`` and ``py::kwargs`` can now be mixed with other positional + arguments when binding functions using pybind11. + `#611 `_. + +* Improved support for C++11 unicode string and character types; added + extensive documentation regarding pybind11's string conversion behavior. + `#624 `_, + `#636 `_, + `#715 `_. + +* pybind11 can now avoid expensive copies when converting Eigen arrays to NumPy + arrays (and vice versa). `#610 `_. + +* The "fast path" in ``py::vectorize`` now works for any full-size group of C or + F-contiguous arrays. The non-fast path is also faster since it no longer performs + copies of the input arguments (except when type conversions are necessary). + `#610 `_. + +* Added fast, unchecked access to NumPy arrays via a proxy object. + `#746 `_. + +* Transparent support for class-specific ``operator new`` and + ``operator delete`` implementations. + `#755 `_. + +* Slimmer and more efficient STL-compatible iterator interface for sequence types. + `#662 `_. + +* Improved custom holder type support. + `#607 `_. + +* ``nullptr`` to ``None`` conversion fixed in various builtin type casters. + `#732 `_. + +* ``enum_`` now exposes its members via a special ``__members__`` attribute. + `#666 `_. + +* ``std::vector`` bindings created using ``stl_bind.h`` can now optionally + implement the buffer protocol. `#488 `_. + +* Automated C++ reference documentation using doxygen and breathe. + `#598 `_. + +* Added minimum compiler version assertions. + `#727 `_. + +* Improved compatibility with C++1z. + `#677 `_. + +* Improved ``py::capsule`` API. Can be used to implement cleanup + callbacks that are involved at module destruction time. + `#752 `_. + +* Various minor improvements and fixes. + `#595 `_, + `#588 `_, + `#589 `_, + `#603 `_, + `#619 `_, + `#648 `_, + `#695 `_, + `#720 `_, + `#723 `_, + `#729 `_, + `#724 `_, + `#742 `_, + `#753 `_. + +v2.0.1 (Jan 4, 2017) +----------------------------------------------------- + +* Fix pointer to reference error in type_caster on MSVC + `#583 `_. + +* Fixed a segmentation in the test suite due to a typo + `cd7eac `_. + +v2.0.0 (Jan 1, 2017) +----------------------------------------------------- + +* Fixed a reference counting regression affecting types with custom metaclasses + (introduced in v2.0.0-rc1). + `#571 `_. + +* Quenched a CMake policy warning. + `#570 `_. + +v2.0.0-rc1 (Dec 23, 2016) +----------------------------------------------------- + +The pybind11 developers are excited to issue a release candidate of pybind11 +with a subsequent v2.0.0 release planned in early January next year. + +An incredible amount of effort by went into pybind11 over the last ~5 months, +leading to a release that is jam-packed with exciting new features and numerous +usability improvements. The following list links PRs or individual commits +whenever applicable. + +Happy Christmas! + +* Support for binding C++ class hierarchies that make use of multiple + inheritance. `#410 `_. + +* PyPy support: pybind11 now supports nightly builds of PyPy and will + interoperate with the future 5.7 release. No code changes are necessary, + everything "just" works as usual. Note that we only target the Python 2.7 + branch for now; support for 3.x will be added once its ``cpyext`` extension + support catches up. A few minor features remain unsupported for the time + being (notably dynamic attributes in custom types). + `#527 `_. + +* Significant work on the documentation -- in particular, the monolithic + ``advanced.rst`` file was restructured into a easier to read hierarchical + organization. `#448 `_. + +* Many NumPy-related improvements: + + 1. Object-oriented API to access and modify NumPy ``ndarray`` instances, + replicating much of the corresponding NumPy C API functionality. + `#402 `_. + + 2. NumPy array ``dtype`` array descriptors are now first-class citizens and + are exposed via a new class ``py::dtype``. + + 3. Structured dtypes can be registered using the ``PYBIND11_NUMPY_DTYPE()`` + macro. Special ``array`` constructors accepting dtype objects were also + added. + + One potential caveat involving this change: format descriptor strings + should now be accessed via ``format_descriptor::format()`` (however, for + compatibility purposes, the old syntax ``format_descriptor::value`` will + still work for non-structured data types). `#308 + `_. + + 4. Further improvements to support structured dtypes throughout the system. + `#472 `_, + `#474 `_, + `#459 `_, + `#453 `_, + `#452 `_, and + `#505 `_. + + 5. Fast access operators. `#497 `_. + + 6. Constructors for arrays whose storage is owned by another object. + `#440 `_. + + 7. Added constructors for ``array`` and ``array_t`` explicitly accepting shape + and strides; if strides are not provided, they are deduced assuming + C-contiguity. Also added simplified constructors for 1-dimensional case. + + 8. Added buffer/NumPy support for ``char[N]`` and ``std::array`` types. + + 9. Added ``memoryview`` wrapper type which is constructible from ``buffer_info``. + +* Eigen: many additional conversions and support for non-contiguous + arrays/slices. + `#427 `_, + `#315 `_, + `#316 `_, + `#312 `_, and + `#267 `_ + +* Incompatible changes in ``class_<...>::class_()``: + + 1. Declarations of types that provide access via the buffer protocol must + now include the ``py::buffer_protocol()`` annotation as an argument to + the ``class_`` constructor. + + 2. Declarations of types that require a custom metaclass (i.e. all classes + which include static properties via commands such as + ``def_readwrite_static()``) must now include the ``py::metaclass()`` + annotation as an argument to the ``class_`` constructor. + + These two changes were necessary to make type definitions in pybind11 + future-proof, and to support PyPy via its cpyext mechanism. `#527 + `_. + + + 3. This version of pybind11 uses a redesigned mechanism for instantiating + trampoline classes that are used to override virtual methods from within + Python. This led to the following user-visible syntax change: instead of + + .. code-block:: cpp + + py::class_("MyClass") + .alias() + .... + + write + + .. code-block:: cpp + + py::class_("MyClass") + .... + + Importantly, both the original and the trampoline class are now + specified as an arguments (in arbitrary order) to the ``py::class_`` + template, and the ``alias<..>()`` call is gone. The new scheme has zero + overhead in cases when Python doesn't override any functions of the + underlying C++ class. `rev. 86d825 + `_. + +* Added ``eval`` and ``eval_file`` functions for evaluating expressions and + statements from a string or file. `rev. 0d3fc3 + `_. + +* pybind11 can now create types with a modifiable dictionary. + `#437 `_ and + `#444 `_. + +* Support for translation of arbitrary C++ exceptions to Python counterparts. + `#296 `_ and + `#273 `_. + +* Report full backtraces through mixed C++/Python code, better reporting for + import errors, fixed GIL management in exception processing. + `#537 `_, + `#494 `_, + `rev. e72d95 `_, and + `rev. 099d6e `_. + +* Support for bit-level operations, comparisons, and serialization of C++ + enumerations. `#503 `_, + `#508 `_, + `#380 `_, + `#309 `_. + `#311 `_. + +* The ``class_`` constructor now accepts its template arguments in any order. + `#385 `_. + +* Attribute and item accessors now have a more complete interface which makes + it possible to chain attributes as in + ``obj.attr("a")[key].attr("b").attr("method")(1, 2, 3)``. `#425 + `_. + +* Major redesign of the default and conversion constructors in ``pytypes.h``. + `#464 `_. + +* Added built-in support for ``std::shared_ptr`` holder type. It is no longer + necessary to to include a declaration of the form + ``PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr)`` (though continuing to + do so won't cause an error). + `#454 `_. + +* New ``py::overload_cast`` casting operator to select among multiple possible + overloads of a function. An example: + + .. code-block:: cpp + + py::class_(m, "Pet") + .def("set", py::overload_cast(&Pet::set), "Set the pet's age") + .def("set", py::overload_cast(&Pet::set), "Set the pet's name"); + + This feature only works on C++14-capable compilers. + `#541 `_. + +* C++ types are automatically cast to Python types, e.g. when assigning + them as an attribute. For instance, the following is now legal: + + .. code-block:: cpp + + py::module m = /* ... */ + m.attr("constant") = 123; + + (Previously, a ``py::cast`` call was necessary to avoid a compilation error.) + `#551 `_. + +* Redesigned ``pytest``-based test suite. `#321 `_. + +* Instance tracking to detect reference leaks in test suite. `#324 `_ + +* pybind11 can now distinguish between multiple different instances that are + located at the same memory address, but which have different types. + `#329 `_. + +* Improved logic in ``move`` return value policy. + `#510 `_, + `#297 `_. + +* Generalized unpacking API to permit calling Python functions from C++ using + notation such as ``foo(a1, a2, *args, "ka"_a=1, "kb"_a=2, **kwargs)``. `#372 `_. + +* ``py::print()`` function whose behavior matches that of the native Python + ``print()`` function. `#372 `_. + +* Added ``py::dict`` keyword constructor:``auto d = dict("number"_a=42, + "name"_a="World");``. `#372 `_. + +* Added ``py::str::format()`` method and ``_s`` literal: ``py::str s = "1 + 2 + = {}"_s.format(3);``. `#372 `_. + +* Added ``py::repr()`` function which is equivalent to Python's builtin + ``repr()``. `#333 `_. + +* Improved construction and destruction logic for holder types. It is now + possible to reference instances with smart pointer holder types without + constructing the holder if desired. The ``PYBIND11_DECLARE_HOLDER_TYPE`` + macro now accepts an optional second parameter to indicate whether the holder + type uses intrusive reference counting. + `#533 `_ and + `#561 `_. + +* Mapping a stateless C++ function to Python and back is now "for free" (i.e. + no extra indirections or argument conversion overheads). `rev. 954b79 + `_. + +* Bindings for ``std::valarray``. + `#545 `_. + +* Improved support for C++17 capable compilers. + `#562 `_. + +* Bindings for ``std::optional``. + `#475 `_, + `#476 `_, + `#479 `_, + `#499 `_, and + `#501 `_. + +* ``stl_bind.h``: general improvements and support for ``std::map`` and + ``std::unordered_map``. + `#490 `_, + `#282 `_, + `#235 `_. + +* The ``std::tuple``, ``std::pair``, ``std::list``, and ``std::vector`` type + casters now accept any Python sequence type as input. `rev. 107285 + `_. + +* Improved CMake Python detection on multi-architecture Linux. + `#532 `_. + +* Infrastructure to selectively disable or enable parts of the automatically + generated docstrings. `#486 `_. + +* ``reference`` and ``reference_internal`` are now the default return value + properties for static and non-static properties, respectively. `#473 + `_. (the previous defaults + were ``automatic``). `#473 `_. + +* Support for ``std::unique_ptr`` with non-default deleters or no deleter at + all (``py::nodelete``). `#384 `_. + +* Deprecated ``handle::call()`` method. The new syntax to call Python + functions is simply ``handle()``. It can also be invoked explicitly via + ``handle::operator()``, where ``X`` is an optional return value policy. + +* Print more informative error messages when ``make_tuple()`` or ``cast()`` + fail. `#262 `_. + +* Creation of holder types for classes deriving from + ``std::enable_shared_from_this<>`` now also works for ``const`` values. + `#260 `_. + +* ``make_iterator()`` improvements for better compatibility with various + types (now uses prefix increment operator); it now also accepts iterators + with different begin/end types as long as they are equality comparable. + `#247 `_. + +* ``arg()`` now accepts a wider range of argument types for default values. + `#244 `_. + +* Support ``keep_alive`` where the nurse object may be ``None``. `#341 + `_. + +* Added constructors for ``str`` and ``bytes`` from zero-terminated char + pointers, and from char pointers and length. Added constructors for ``str`` + from ``bytes`` and for ``bytes`` from ``str``, which will perform UTF-8 + decoding/encoding as required. + +* Many other improvements of library internals without user-visible changes + + +1.8.1 (July 12, 2016) +---------------------- +* Fixed a rare but potentially very severe issue when the garbage collector ran + during pybind11 type creation. + +1.8.0 (June 14, 2016) +---------------------- +* Redesigned CMake build system which exports a convenient + ``pybind11_add_module`` function to parent projects. +* ``std::vector<>`` type bindings analogous to Boost.Python's ``indexing_suite`` +* Transparent conversion of sparse and dense Eigen matrices and vectors (``eigen.h``) +* Added an ``ExtraFlags`` template argument to the NumPy ``array_t<>`` wrapper + to disable an enforced cast that may lose precision, e.g. to create overloads + for different precisions and complex vs real-valued matrices. +* Prevent implicit conversion of floating point values to integral types in + function arguments +* Fixed incorrect default return value policy for functions returning a shared + pointer +* Don't allow registering a type via ``class_`` twice +* Don't allow casting a ``None`` value into a C++ lvalue reference +* Fixed a crash in ``enum_::operator==`` that was triggered by the ``help()`` command +* Improved detection of whether or not custom C++ types can be copy/move-constructed +* Extended ``str`` type to also work with ``bytes`` instances +* Added a ``"name"_a`` user defined string literal that is equivalent to ``py::arg("name")``. +* When specifying function arguments via ``py::arg``, the test that verifies + the number of arguments now runs at compile time. +* Added ``[[noreturn]]`` attribute to ``pybind11_fail()`` to quench some + compiler warnings +* List function arguments in exception text when the dispatch code cannot find + a matching overload +* Added ``PYBIND11_OVERLOAD_NAME`` and ``PYBIND11_OVERLOAD_PURE_NAME`` macros which + can be used to override virtual methods whose name differs in C++ and Python + (e.g. ``__call__`` and ``operator()``) +* Various minor ``iterator`` and ``make_iterator()`` improvements +* Transparently support ``__bool__`` on Python 2.x and Python 3.x +* Fixed issue with destructor of unpickled object not being called +* Minor CMake build system improvements on Windows +* New ``pybind11::args`` and ``pybind11::kwargs`` types to create functions which + take an arbitrary number of arguments and keyword arguments +* New syntax to call a Python function from C++ using ``*args`` and ``*kwargs`` +* The functions ``def_property_*`` now correctly process docstring arguments (these + formerly caused a segmentation fault) +* Many ``mkdoc.py`` improvements (enumerations, template arguments, ``DOC()`` + macro accepts more arguments) +* Cygwin support +* Documentation improvements (pickling support, ``keep_alive``, macro usage) + +1.7 (April 30, 2016) +---------------------- +* Added a new ``move`` return value policy that triggers C++11 move semantics. + The automatic return value policy falls back to this case whenever a rvalue + reference is encountered +* Significantly more general GIL state routines that are used instead of + Python's troublesome ``PyGILState_Ensure`` and ``PyGILState_Release`` API +* Redesign of opaque types that drastically simplifies their usage +* Extended ability to pass values of type ``[const] void *`` +* ``keep_alive`` fix: don't fail when there is no patient +* ``functional.h``: acquire the GIL before calling a Python function +* Added Python RAII type wrappers ``none`` and ``iterable`` +* Added ``*args`` and ``*kwargs`` pass-through parameters to + ``pybind11.get_include()`` function +* Iterator improvements and fixes +* Documentation on return value policies and opaque types improved + +1.6 (April 30, 2016) +---------------------- +* Skipped due to upload to PyPI gone wrong and inability to recover + (https://github.com/pypa/packaging-problems/issues/74) + +1.5 (April 21, 2016) +---------------------- +* For polymorphic types, use RTTI to try to return the closest type registered with pybind11 +* Pickling support for serializing and unserializing C++ instances to a byte stream in Python +* Added a convenience routine ``make_iterator()`` which turns a range indicated + by a pair of C++ iterators into a iterable Python object +* Added ``len()`` and a variadic ``make_tuple()`` function +* Addressed a rare issue that could confuse the current virtual function + dispatcher and another that could lead to crashes in multi-threaded + applications +* Added a ``get_include()`` function to the Python module that returns the path + of the directory containing the installed pybind11 header files +* Documentation improvements: import issues, symbol visibility, pickling, limitations +* Added casting support for ``std::reference_wrapper<>`` + +1.4 (April 7, 2016) +-------------------------- +* Transparent type conversion for ``std::wstring`` and ``wchar_t`` +* Allow passing ``nullptr``-valued strings +* Transparent passing of ``void *`` pointers using capsules +* Transparent support for returning values wrapped in ``std::unique_ptr<>`` +* Improved docstring generation for compatibility with Sphinx +* Nicer debug error message when default parameter construction fails +* Support for "opaque" types that bypass the transparent conversion layer for STL containers +* Redesigned type casting interface to avoid ambiguities that could occasionally cause compiler errors +* Redesigned property implementation; fixes crashes due to an unfortunate default return value policy +* Anaconda package generation support + +1.3 (March 8, 2016) +-------------------------- + +* Added support for the Intel C++ compiler (v15+) +* Added support for the STL unordered set/map data structures +* Added support for the STL linked list data structure +* NumPy-style broadcasting support in ``pybind11::vectorize`` +* pybind11 now displays more verbose error messages when ``arg::operator=()`` fails +* pybind11 internal data structures now live in a version-dependent namespace to avoid ABI issues +* Many, many bugfixes involving corner cases and advanced usage + +1.2 (February 7, 2016) +-------------------------- + +* Optional: efficient generation of function signatures at compile time using C++14 +* Switched to a simpler and more general way of dealing with function default + arguments. Unused keyword arguments in function calls are now detected and + cause errors as expected +* New ``keep_alive`` call policy analogous to Boost.Python's ``with_custodian_and_ward`` +* New ``pybind11::base<>`` attribute to indicate a subclass relationship +* Improved interface for RAII type wrappers in ``pytypes.h`` +* Use RAII type wrappers consistently within pybind11 itself. This + fixes various potential refcount leaks when exceptions occur +* Added new ``bytes`` RAII type wrapper (maps to ``string`` in Python 2.7) +* Made handle and related RAII classes const correct, using them more + consistently everywhere now +* Got rid of the ugly ``__pybind11__`` attributes on the Python side---they are + now stored in a C++ hash table that is not visible in Python +* Fixed refcount leaks involving NumPy arrays and bound functions +* Vastly improved handling of shared/smart pointers +* Removed an unnecessary copy operation in ``pybind11::vectorize`` +* Fixed naming clashes when both pybind11 and NumPy headers are included +* Added conversions for additional exception types +* Documentation improvements (using multiple extension modules, smart pointers, + other minor clarifications) +* unified infrastructure for parsing variadic arguments in ``class_`` and cpp_function +* Fixed license text (was: ZLIB, should have been: 3-clause BSD) +* Python 3.2 compatibility +* Fixed remaining issues when accessing types in another plugin module +* Added enum comparison and casting methods +* Improved SFINAE-based detection of whether types are copy-constructible +* Eliminated many warnings about unused variables and the use of ``offsetof()`` +* Support for ``std::array<>`` conversions + +1.1 (December 7, 2015) +-------------------------- + +* Documentation improvements (GIL, wrapping functions, casting, fixed many typos) +* Generalized conversion of integer types +* Improved support for casting function objects +* Improved support for ``std::shared_ptr<>`` conversions +* Initial support for ``std::set<>`` conversions +* Fixed type resolution issue for types defined in a separate plugin module +* CMake build system improvements +* Factored out generic functionality to non-templated code (smaller code size) +* Added a code size / compile time benchmark vs Boost.Python +* Added an appveyor CI script + +1.0 (October 15, 2015) +------------------------ +* Initial release diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/classes.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/classes.rst new file mode 100644 index 000000000..4f2167dac --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/classes.rst @@ -0,0 +1,555 @@ +.. _classes: + +Object-oriented code +#################### + +Creating bindings for a custom type +=================================== + +Let's now look at a more complex example where we'll create bindings for a +custom C++ data structure named ``Pet``. Its definition is given below: + +.. code-block:: cpp + + struct Pet { + Pet(const std::string &name) : name(name) { } + void setName(const std::string &name_) { name = name_; } + const std::string &getName() const { return name; } + + std::string name; + }; + +The binding code for ``Pet`` looks as follows: + +.. code-block:: cpp + + #include + + namespace py = pybind11; + + PYBIND11_MODULE(example, m) { + py::class_(m, "Pet") + .def(py::init()) + .def("setName", &Pet::setName) + .def("getName", &Pet::getName); + } + +:class:`class_` creates bindings for a C++ *class* or *struct*-style data +structure. :func:`init` is a convenience function that takes the types of a +constructor's parameters as template arguments and wraps the corresponding +constructor (see the :ref:`custom_constructors` section for details). An +interactive Python session demonstrating this example is shown below: + +.. code-block:: pycon + + % python + >>> import example + >>> p = example.Pet("Molly") + >>> print(p) + + >>> p.getName() + 'Molly' + >>> p.setName("Charly") + >>> p.getName() + 'Charly' + +.. seealso:: + + Static member functions can be bound in the same way using + :func:`class_::def_static`. + +.. note:: + + Binding C++ types in unnamed namespaces (also known as anonymous namespaces) + works reliably on many platforms, but not all. The `XFAIL_CONDITION` in + tests/test_unnamed_namespace_a.py encodes the currently known conditions. + For background see `#4319 `_. + If portability is a concern, it is therefore not recommended to bind C++ + types in unnamed namespaces. It will be safest to manually pick unique + namespace names. + +Keyword and default arguments +============================= +It is possible to specify keyword and default arguments using the syntax +discussed in the previous chapter. Refer to the sections :ref:`keyword_args` +and :ref:`default_args` for details. + +Binding lambda functions +======================== + +Note how ``print(p)`` produced a rather useless summary of our data structure in the example above: + +.. code-block:: pycon + + >>> print(p) + + +To address this, we could bind a utility function that returns a human-readable +summary to the special method slot named ``__repr__``. Unfortunately, there is no +suitable functionality in the ``Pet`` data structure, and it would be nice if +we did not have to change it. This can easily be accomplished by binding a +Lambda function instead: + +.. code-block:: cpp + + py::class_(m, "Pet") + .def(py::init()) + .def("setName", &Pet::setName) + .def("getName", &Pet::getName) + .def("__repr__", + [](const Pet &a) { + return ""; + } + ); + +Both stateless [#f1]_ and stateful lambda closures are supported by pybind11. +With the above change, the same Python code now produces the following output: + +.. code-block:: pycon + + >>> print(p) + + +.. [#f1] Stateless closures are those with an empty pair of brackets ``[]`` as the capture object. + +.. _properties: + +Instance and static fields +========================== + +We can also directly expose the ``name`` field using the +:func:`class_::def_readwrite` method. A similar :func:`class_::def_readonly` +method also exists for ``const`` fields. + +.. code-block:: cpp + + py::class_(m, "Pet") + .def(py::init()) + .def_readwrite("name", &Pet::name) + // ... remainder ... + +This makes it possible to write + +.. code-block:: pycon + + >>> p = example.Pet("Molly") + >>> p.name + 'Molly' + >>> p.name = "Charly" + >>> p.name + 'Charly' + +Now suppose that ``Pet::name`` was a private internal variable +that can only be accessed via setters and getters. + +.. code-block:: cpp + + class Pet { + public: + Pet(const std::string &name) : name(name) { } + void setName(const std::string &name_) { name = name_; } + const std::string &getName() const { return name; } + private: + std::string name; + }; + +In this case, the method :func:`class_::def_property` +(:func:`class_::def_property_readonly` for read-only data) can be used to +provide a field-like interface within Python that will transparently call +the setter and getter functions: + +.. code-block:: cpp + + py::class_(m, "Pet") + .def(py::init()) + .def_property("name", &Pet::getName, &Pet::setName) + // ... remainder ... + +Write only properties can be defined by passing ``nullptr`` as the +input for the read function. + +.. seealso:: + + Similar functions :func:`class_::def_readwrite_static`, + :func:`class_::def_readonly_static` :func:`class_::def_property_static`, + and :func:`class_::def_property_readonly_static` are provided for binding + static variables and properties. Please also see the section on + :ref:`static_properties` in the advanced part of the documentation. + +Dynamic attributes +================== + +Native Python classes can pick up new attributes dynamically: + +.. code-block:: pycon + + >>> class Pet: + ... name = "Molly" + ... + >>> p = Pet() + >>> p.name = "Charly" # overwrite existing + >>> p.age = 2 # dynamically add a new attribute + +By default, classes exported from C++ do not support this and the only writable +attributes are the ones explicitly defined using :func:`class_::def_readwrite` +or :func:`class_::def_property`. + +.. code-block:: cpp + + py::class_(m, "Pet") + .def(py::init<>()) + .def_readwrite("name", &Pet::name); + +Trying to set any other attribute results in an error: + +.. code-block:: pycon + + >>> p = example.Pet() + >>> p.name = "Charly" # OK, attribute defined in C++ + >>> p.age = 2 # fail + AttributeError: 'Pet' object has no attribute 'age' + +To enable dynamic attributes for C++ classes, the :class:`py::dynamic_attr` tag +must be added to the :class:`py::class_` constructor: + +.. code-block:: cpp + + py::class_(m, "Pet", py::dynamic_attr()) + .def(py::init<>()) + .def_readwrite("name", &Pet::name); + +Now everything works as expected: + +.. code-block:: pycon + + >>> p = example.Pet() + >>> p.name = "Charly" # OK, overwrite value in C++ + >>> p.age = 2 # OK, dynamically add a new attribute + >>> p.__dict__ # just like a native Python class + {'age': 2} + +Note that there is a small runtime cost for a class with dynamic attributes. +Not only because of the addition of a ``__dict__``, but also because of more +expensive garbage collection tracking which must be activated to resolve +possible circular references. Native Python classes incur this same cost by +default, so this is not anything to worry about. By default, pybind11 classes +are more efficient than native Python classes. Enabling dynamic attributes +just brings them on par. + +.. _inheritance: + +Inheritance and automatic downcasting +===================================== + +Suppose now that the example consists of two data structures with an +inheritance relationship: + +.. code-block:: cpp + + struct Pet { + Pet(const std::string &name) : name(name) { } + std::string name; + }; + + struct Dog : Pet { + Dog(const std::string &name) : Pet(name) { } + std::string bark() const { return "woof!"; } + }; + +There are two different ways of indicating a hierarchical relationship to +pybind11: the first specifies the C++ base class as an extra template +parameter of the :class:`class_`: + +.. code-block:: cpp + + py::class_(m, "Pet") + .def(py::init()) + .def_readwrite("name", &Pet::name); + + // Method 1: template parameter: + py::class_(m, "Dog") + .def(py::init()) + .def("bark", &Dog::bark); + +Alternatively, we can also assign a name to the previously bound ``Pet`` +:class:`class_` object and reference it when binding the ``Dog`` class: + +.. code-block:: cpp + + py::class_ pet(m, "Pet"); + pet.def(py::init()) + .def_readwrite("name", &Pet::name); + + // Method 2: pass parent class_ object: + py::class_(m, "Dog", pet /* <- specify Python parent type */) + .def(py::init()) + .def("bark", &Dog::bark); + +Functionality-wise, both approaches are equivalent. Afterwards, instances will +expose fields and methods of both types: + +.. code-block:: pycon + + >>> p = example.Dog("Molly") + >>> p.name + 'Molly' + >>> p.bark() + 'woof!' + +The C++ classes defined above are regular non-polymorphic types with an +inheritance relationship. This is reflected in Python: + +.. code-block:: cpp + + // Return a base pointer to a derived instance + m.def("pet_store", []() { return std::unique_ptr(new Dog("Molly")); }); + +.. code-block:: pycon + + >>> p = example.pet_store() + >>> type(p) # `Dog` instance behind `Pet` pointer + Pet # no pointer downcasting for regular non-polymorphic types + >>> p.bark() + AttributeError: 'Pet' object has no attribute 'bark' + +The function returned a ``Dog`` instance, but because it's a non-polymorphic +type behind a base pointer, Python only sees a ``Pet``. In C++, a type is only +considered polymorphic if it has at least one virtual function and pybind11 +will automatically recognize this: + +.. code-block:: cpp + + struct PolymorphicPet { + virtual ~PolymorphicPet() = default; + }; + + struct PolymorphicDog : PolymorphicPet { + std::string bark() const { return "woof!"; } + }; + + // Same binding code + py::class_(m, "PolymorphicPet"); + py::class_(m, "PolymorphicDog") + .def(py::init<>()) + .def("bark", &PolymorphicDog::bark); + + // Again, return a base pointer to a derived instance + m.def("pet_store2", []() { return std::unique_ptr(new PolymorphicDog); }); + +.. code-block:: pycon + + >>> p = example.pet_store2() + >>> type(p) + PolymorphicDog # automatically downcast + >>> p.bark() + 'woof!' + +Given a pointer to a polymorphic base, pybind11 performs automatic downcasting +to the actual derived type. Note that this goes beyond the usual situation in +C++: we don't just get access to the virtual functions of the base, we get the +concrete derived type including functions and attributes that the base type may +not even be aware of. + +.. seealso:: + + For more information about polymorphic behavior see :ref:`overriding_virtuals`. + + +Overloaded methods +================== + +Sometimes there are several overloaded C++ methods with the same name taking +different kinds of input arguments: + +.. code-block:: cpp + + struct Pet { + Pet(const std::string &name, int age) : name(name), age(age) { } + + void set(int age_) { age = age_; } + void set(const std::string &name_) { name = name_; } + + std::string name; + int age; + }; + +Attempting to bind ``Pet::set`` will cause an error since the compiler does not +know which method the user intended to select. We can disambiguate by casting +them to function pointers. Binding multiple functions to the same Python name +automatically creates a chain of function overloads that will be tried in +sequence. + +.. code-block:: cpp + + py::class_(m, "Pet") + .def(py::init()) + .def("set", static_cast(&Pet::set), "Set the pet's age") + .def("set", static_cast(&Pet::set), "Set the pet's name"); + +The overload signatures are also visible in the method's docstring: + +.. code-block:: pycon + + >>> help(example.Pet) + + class Pet(__builtin__.object) + | Methods defined here: + | + | __init__(...) + | Signature : (Pet, str, int) -> NoneType + | + | set(...) + | 1. Signature : (Pet, int) -> NoneType + | + | Set the pet's age + | + | 2. Signature : (Pet, str) -> NoneType + | + | Set the pet's name + +If you have a C++14 compatible compiler [#cpp14]_, you can use an alternative +syntax to cast the overloaded function: + +.. code-block:: cpp + + py::class_(m, "Pet") + .def("set", py::overload_cast(&Pet::set), "Set the pet's age") + .def("set", py::overload_cast(&Pet::set), "Set the pet's name"); + +Here, ``py::overload_cast`` only requires the parameter types to be specified. +The return type and class are deduced. This avoids the additional noise of +``void (Pet::*)()`` as seen in the raw cast. If a function is overloaded based +on constness, the ``py::const_`` tag should be used: + +.. code-block:: cpp + + struct Widget { + int foo(int x, float y); + int foo(int x, float y) const; + }; + + py::class_(m, "Widget") + .def("foo_mutable", py::overload_cast(&Widget::foo)) + .def("foo_const", py::overload_cast(&Widget::foo, py::const_)); + +If you prefer the ``py::overload_cast`` syntax but have a C++11 compatible compiler only, +you can use ``py::detail::overload_cast_impl`` with an additional set of parentheses: + +.. code-block:: cpp + + template + using overload_cast_ = pybind11::detail::overload_cast_impl; + + py::class_(m, "Pet") + .def("set", overload_cast_()(&Pet::set), "Set the pet's age") + .def("set", overload_cast_()(&Pet::set), "Set the pet's name"); + +.. [#cpp14] A compiler which supports the ``-std=c++14`` flag. + +.. note:: + + To define multiple overloaded constructors, simply declare one after the + other using the ``.def(py::init<...>())`` syntax. The existing machinery + for specifying keyword and default arguments also works. + +Enumerations and internal types +=============================== + +Let's now suppose that the example class contains internal types like enumerations, e.g.: + +.. code-block:: cpp + + struct Pet { + enum Kind { + Dog = 0, + Cat + }; + + struct Attributes { + float age = 0; + }; + + Pet(const std::string &name, Kind type) : name(name), type(type) { } + + std::string name; + Kind type; + Attributes attr; + }; + +The binding code for this example looks as follows: + +.. code-block:: cpp + + py::class_ pet(m, "Pet"); + + pet.def(py::init()) + .def_readwrite("name", &Pet::name) + .def_readwrite("type", &Pet::type) + .def_readwrite("attr", &Pet::attr); + + py::enum_(pet, "Kind") + .value("Dog", Pet::Kind::Dog) + .value("Cat", Pet::Kind::Cat) + .export_values(); + + py::class_(pet, "Attributes") + .def(py::init<>()) + .def_readwrite("age", &Pet::Attributes::age); + + +To ensure that the nested types ``Kind`` and ``Attributes`` are created within the scope of ``Pet``, the +``pet`` :class:`class_` instance must be supplied to the :class:`enum_` and :class:`class_` +constructor. The :func:`enum_::export_values` function exports the enum entries +into the parent scope, which should be skipped for newer C++11-style strongly +typed enums. + +.. code-block:: pycon + + >>> p = Pet("Lucy", Pet.Cat) + >>> p.type + Kind.Cat + >>> int(p.type) + 1L + +The entries defined by the enumeration type are exposed in the ``__members__`` property: + +.. code-block:: pycon + + >>> Pet.Kind.__members__ + {'Dog': Kind.Dog, 'Cat': Kind.Cat} + +The ``name`` property returns the name of the enum value as a unicode string. + +.. note:: + + It is also possible to use ``str(enum)``, however these accomplish different + goals. The following shows how these two approaches differ. + + .. code-block:: pycon + + >>> p = Pet("Lucy", Pet.Cat) + >>> pet_type = p.type + >>> pet_type + Pet.Cat + >>> str(pet_type) + 'Pet.Cat' + >>> pet_type.name + 'Cat' + +.. note:: + + When the special tag ``py::arithmetic()`` is specified to the ``enum_`` + constructor, pybind11 creates an enumeration that also supports rudimentary + arithmetic and bit-level operations like comparisons, and, or, xor, negation, + etc. + + .. code-block:: cpp + + py::enum_(pet, "Kind", py::arithmetic()) + ... + + By default, these are omitted to conserve space. + +.. warning:: + + Contrary to Python customs, enum values from the wrappers should not be compared using ``is``, but with ``==`` (see `#1177 `_ for background). diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/cmake/index.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/cmake/index.rst new file mode 100644 index 000000000..eaf66d70f --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/cmake/index.rst @@ -0,0 +1,8 @@ +CMake helpers +------------- + +Pybind11 can be used with ``add_subdirectory(extern/pybind11)``, or from an +install with ``find_package(pybind11 CONFIG)``. The interface provided in +either case is functionally identical. + +.. cmake-module:: ../../tools/pybind11Config.cmake.in diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/compiling.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/compiling.rst new file mode 100644 index 000000000..1fd098bec --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/compiling.rst @@ -0,0 +1,641 @@ +.. _compiling: + +Build systems +############# + +.. _build-setuptools: + +Building with setuptools +======================== + +For projects on PyPI, building with setuptools is the way to go. Sylvain Corlay +has kindly provided an example project which shows how to set up everything, +including automatic generation of documentation using Sphinx. Please refer to +the [python_example]_ repository. + +.. [python_example] https://github.com/pybind/python_example + +A helper file is provided with pybind11 that can simplify usage with setuptools. + +To use pybind11 inside your ``setup.py``, you have to have some system to +ensure that ``pybind11`` is installed when you build your package. There are +four possible ways to do this, and pybind11 supports all four: You can ask all +users to install pybind11 beforehand (bad), you can use +:ref:`setup_helpers-pep518` (good, but very new and requires Pip 10), +:ref:`setup_helpers-setup_requires` (discouraged by Python packagers now that +PEP 518 is available, but it still works everywhere), or you can +:ref:`setup_helpers-copy-manually` (always works but you have to manually sync +your copy to get updates). + +An example of a ``setup.py`` using pybind11's helpers: + +.. code-block:: python + + from glob import glob + from setuptools import setup + from pybind11.setup_helpers import Pybind11Extension + + ext_modules = [ + Pybind11Extension( + "python_example", + sorted(glob("src/*.cpp")), # Sort source files for reproducibility + ), + ] + + setup(..., ext_modules=ext_modules) + +If you want to do an automatic search for the highest supported C++ standard, +that is supported via a ``build_ext`` command override; it will only affect +``Pybind11Extensions``: + +.. code-block:: python + + from glob import glob + from setuptools import setup + from pybind11.setup_helpers import Pybind11Extension, build_ext + + ext_modules = [ + Pybind11Extension( + "python_example", + sorted(glob("src/*.cpp")), + ), + ] + + setup(..., cmdclass={"build_ext": build_ext}, ext_modules=ext_modules) + +If you have single-file extension modules that are directly stored in the +Python source tree (``foo.cpp`` in the same directory as where a ``foo.py`` +would be located), you can also generate ``Pybind11Extensions`` using +``setup_helpers.intree_extensions``: ``intree_extensions(["path/to/foo.cpp", +...])`` returns a list of ``Pybind11Extensions`` which can be passed to +``ext_modules``, possibly after further customizing their attributes +(``libraries``, ``include_dirs``, etc.). By doing so, a ``foo.*.so`` extension +module will be generated and made available upon installation. + +``intree_extension`` will automatically detect if you are using a ``src``-style +layout (as long as no namespace packages are involved), but you can also +explicitly pass ``package_dir`` to it (as in ``setuptools.setup``). + +Since pybind11 does not require NumPy when building, a light-weight replacement +for NumPy's parallel compilation distutils tool is included. Use it like this: + +.. code-block:: python + + from pybind11.setup_helpers import ParallelCompile + + # Optional multithreaded build + ParallelCompile("NPY_NUM_BUILD_JOBS").install() + + setup(...) + +The argument is the name of an environment variable to control the number of +threads, such as ``NPY_NUM_BUILD_JOBS`` (as used by NumPy), though you can set +something different if you want; ``CMAKE_BUILD_PARALLEL_LEVEL`` is another choice +a user might expect. You can also pass ``default=N`` to set the default number +of threads (0 will take the number of threads available) and ``max=N``, the +maximum number of threads; if you have a large extension you may want set this +to a memory dependent number. + +If you are developing rapidly and have a lot of C++ files, you may want to +avoid rebuilding files that have not changed. For simple cases were you are +using ``pip install -e .`` and do not have local headers, you can skip the +rebuild if an object file is newer than its source (headers are not checked!) +with the following: + +.. code-block:: python + + from pybind11.setup_helpers import ParallelCompile, naive_recompile + + ParallelCompile("NPY_NUM_BUILD_JOBS", needs_recompile=naive_recompile).install() + + +If you have a more complex build, you can implement a smarter function and pass +it to ``needs_recompile``, or you can use [Ccache]_ instead. ``CXX="cache g++" +pip install -e .`` would be the way to use it with GCC, for example. Unlike the +simple solution, this even works even when not compiling in editable mode, but +it does require Ccache to be installed. + +Keep in mind that Pip will not even attempt to rebuild if it thinks it has +already built a copy of your code, which it deduces from the version number. +One way to avoid this is to use [setuptools_scm]_, which will generate a +version number that includes the number of commits since your last tag and a +hash for a dirty directory. Another way to force a rebuild is purge your cache +or use Pip's ``--no-cache-dir`` option. + +.. [Ccache] https://ccache.dev + +.. [setuptools_scm] https://github.com/pypa/setuptools_scm + +.. _setup_helpers-pep518: + +PEP 518 requirements (Pip 10+ required) +--------------------------------------- + +If you use `PEP 518's `_ +``pyproject.toml`` file, you can ensure that ``pybind11`` is available during +the compilation of your project. When this file exists, Pip will make a new +virtual environment, download just the packages listed here in ``requires=``, +and build a wheel (binary Python package). It will then throw away the +environment, and install your wheel. + +Your ``pyproject.toml`` file will likely look something like this: + +.. code-block:: toml + + [build-system] + requires = ["setuptools>=42", "wheel", "pybind11~=2.6.1"] + build-backend = "setuptools.build_meta" + +.. note:: + + The main drawback to this method is that a `PEP 517`_ compliant build tool, + such as Pip 10+, is required for this approach to work; older versions of + Pip completely ignore this file. If you distribute binaries (called wheels + in Python) using something like `cibuildwheel`_, remember that ``setup.py`` + and ``pyproject.toml`` are not even contained in the wheel, so this high + Pip requirement is only for source builds, and will not affect users of + your binary wheels. If you are building SDists and wheels, then + `pypa-build`_ is the recommended official tool. + +.. _PEP 517: https://www.python.org/dev/peps/pep-0517/ +.. _cibuildwheel: https://cibuildwheel.readthedocs.io +.. _pypa-build: https://pypa-build.readthedocs.io/en/latest/ + +.. _setup_helpers-setup_requires: + +Classic ``setup_requires`` +-------------------------- + +If you want to support old versions of Pip with the classic +``setup_requires=["pybind11"]`` keyword argument to setup, which triggers a +two-phase ``setup.py`` run, then you will need to use something like this to +ensure the first pass works (which has not yet installed the ``setup_requires`` +packages, since it can't install something it does not know about): + +.. code-block:: python + + try: + from pybind11.setup_helpers import Pybind11Extension + except ImportError: + from setuptools import Extension as Pybind11Extension + + +It doesn't matter that the Extension class is not the enhanced subclass for the +first pass run; and the second pass will have the ``setup_requires`` +requirements. + +This is obviously more of a hack than the PEP 518 method, but it supports +ancient versions of Pip. + +.. _setup_helpers-copy-manually: + +Copy manually +------------- + +You can also copy ``setup_helpers.py`` directly to your project; it was +designed to be usable standalone, like the old example ``setup.py``. You can +set ``include_pybind11=False`` to skip including the pybind11 package headers, +so you can use it with git submodules and a specific git version. If you use +this, you will need to import from a local file in ``setup.py`` and ensure the +helper file is part of your MANIFEST. + + +Closely related, if you include pybind11 as a subproject, you can run the +``setup_helpers.py`` inplace. If loaded correctly, this should even pick up +the correct include for pybind11, though you can turn it off as shown above if +you want to input it manually. + +Suggested usage if you have pybind11 as a submodule in ``extern/pybind11``: + +.. code-block:: python + + DIR = os.path.abspath(os.path.dirname(__file__)) + + sys.path.append(os.path.join(DIR, "extern", "pybind11")) + from pybind11.setup_helpers import Pybind11Extension # noqa: E402 + + del sys.path[-1] + + +.. versionchanged:: 2.6 + + Added ``setup_helpers`` file. + +Building with cppimport +======================== + +[cppimport]_ is a small Python import hook that determines whether there is a C++ +source file whose name matches the requested module. If there is, the file is +compiled as a Python extension using pybind11 and placed in the same folder as +the C++ source file. Python is then able to find the module and load it. + +.. [cppimport] https://github.com/tbenthompson/cppimport + +.. _cmake: + +Building with CMake +=================== + +For C++ codebases that have an existing CMake-based build system, a Python +extension module can be created with just a few lines of code: + +.. code-block:: cmake + + cmake_minimum_required(VERSION 3.5...3.26) + project(example LANGUAGES CXX) + + add_subdirectory(pybind11) + pybind11_add_module(example example.cpp) + +This assumes that the pybind11 repository is located in a subdirectory named +:file:`pybind11` and that the code is located in a file named :file:`example.cpp`. +The CMake command ``add_subdirectory`` will import the pybind11 project which +provides the ``pybind11_add_module`` function. It will take care of all the +details needed to build a Python extension module on any platform. + +A working sample project, including a way to invoke CMake from :file:`setup.py` for +PyPI integration, can be found in the [cmake_example]_ repository. + +.. [cmake_example] https://github.com/pybind/cmake_example + +.. versionchanged:: 2.6 + CMake 3.4+ is required. + +.. versionchanged:: 2.11 + CMake 3.5+ is required. + +Further information can be found at :doc:`cmake/index`. + +pybind11_add_module +------------------- + +To ease the creation of Python extension modules, pybind11 provides a CMake +function with the following signature: + +.. code-block:: cmake + + pybind11_add_module( [MODULE | SHARED] [EXCLUDE_FROM_ALL] + [NO_EXTRAS] [THIN_LTO] [OPT_SIZE] source1 [source2 ...]) + +This function behaves very much like CMake's builtin ``add_library`` (in fact, +it's a wrapper function around that command). It will add a library target +called ```` to be built from the listed source files. In addition, it +will take care of all the Python-specific compiler and linker flags as well +as the OS- and Python-version-specific file extension. The produced target +```` can be further manipulated with regular CMake commands. + +``MODULE`` or ``SHARED`` may be given to specify the type of library. If no +type is given, ``MODULE`` is used by default which ensures the creation of a +Python-exclusive module. Specifying ``SHARED`` will create a more traditional +dynamic library which can also be linked from elsewhere. ``EXCLUDE_FROM_ALL`` +removes this target from the default build (see CMake docs for details). + +Since pybind11 is a template library, ``pybind11_add_module`` adds compiler +flags to ensure high quality code generation without bloat arising from long +symbol names and duplication of code in different translation units. It +sets default visibility to *hidden*, which is required for some pybind11 +features and functionality when attempting to load multiple pybind11 modules +compiled under different pybind11 versions. It also adds additional flags +enabling LTO (Link Time Optimization) and strip unneeded symbols. See the +:ref:`FAQ entry ` for a more detailed explanation. These +latter optimizations are never applied in ``Debug`` mode. If ``NO_EXTRAS`` is +given, they will always be disabled, even in ``Release`` mode. However, this +will result in code bloat and is generally not recommended. + +As stated above, LTO is enabled by default. Some newer compilers also support +different flavors of LTO such as `ThinLTO`_. Setting ``THIN_LTO`` will cause +the function to prefer this flavor if available. The function falls back to +regular LTO if ``-flto=thin`` is not available. If +``CMAKE_INTERPROCEDURAL_OPTIMIZATION`` is set (either ``ON`` or ``OFF``), then +that will be respected instead of the built-in flag search. + +.. note:: + + If you want to set the property form on targets or the + ``CMAKE_INTERPROCEDURAL_OPTIMIZATION_`` versions of this, you should + still use ``set(CMAKE_INTERPROCEDURAL_OPTIMIZATION OFF)`` (otherwise a + no-op) to disable pybind11's ipo flags. + +The ``OPT_SIZE`` flag enables size-based optimization equivalent to the +standard ``/Os`` or ``-Os`` compiler flags and the ``MinSizeRel`` build type, +which avoid optimizations that that can substantially increase the size of the +resulting binary. This flag is particularly useful in projects that are split +into performance-critical parts and associated bindings. In this case, we can +compile the project in release mode (and hence, optimize performance globally), +and specify ``OPT_SIZE`` for the binding target, where size might be the main +concern as performance is often less critical here. A ~25% size reduction has +been observed in practice. This flag only changes the optimization behavior at +a per-target level and takes precedence over the global CMake build type +(``Release``, ``RelWithDebInfo``) except for ``Debug`` builds, where +optimizations remain disabled. + +.. _ThinLTO: http://clang.llvm.org/docs/ThinLTO.html + +Configuration variables +----------------------- + +By default, pybind11 will compile modules with the compiler default or the +minimum standard required by pybind11, whichever is higher. You can set the +standard explicitly with +`CMAKE_CXX_STANDARD `_: + +.. code-block:: cmake + + set(CMAKE_CXX_STANDARD 14 CACHE STRING "C++ version selection") # or 11, 14, 17, 20 + set(CMAKE_CXX_STANDARD_REQUIRED ON) # optional, ensure standard is supported + set(CMAKE_CXX_EXTENSIONS OFF) # optional, keep compiler extensions off + +The variables can also be set when calling CMake from the command line using +the ``-D=`` flag. You can also manually set ``CXX_STANDARD`` +on a target or use ``target_compile_features`` on your targets - anything that +CMake supports. + +Classic Python support: The target Python version can be selected by setting +``PYBIND11_PYTHON_VERSION`` or an exact Python installation can be specified +with ``PYTHON_EXECUTABLE``. For example: + +.. code-block:: bash + + cmake -DPYBIND11_PYTHON_VERSION=3.6 .. + + # Another method: + cmake -DPYTHON_EXECUTABLE=/path/to/python .. + + # This often is a good way to get the current Python, works in environments: + cmake -DPYTHON_EXECUTABLE=$(python3 -c "import sys; print(sys.executable)") .. + + +find_package vs. add_subdirectory +--------------------------------- + +For CMake-based projects that don't include the pybind11 repository internally, +an external installation can be detected through ``find_package(pybind11)``. +See the `Config file`_ docstring for details of relevant CMake variables. + +.. code-block:: cmake + + cmake_minimum_required(VERSION 3.4...3.18) + project(example LANGUAGES CXX) + + find_package(pybind11 REQUIRED) + pybind11_add_module(example example.cpp) + +Note that ``find_package(pybind11)`` will only work correctly if pybind11 +has been correctly installed on the system, e. g. after downloading or cloning +the pybind11 repository : + +.. code-block:: bash + + # Classic CMake + cd pybind11 + mkdir build + cd build + cmake .. + make install + + # CMake 3.15+ + cd pybind11 + cmake -S . -B build + cmake --build build -j 2 # Build on 2 cores + cmake --install build + +Once detected, the aforementioned ``pybind11_add_module`` can be employed as +before. The function usage and configuration variables are identical no matter +if pybind11 is added as a subdirectory or found as an installed package. You +can refer to the same [cmake_example]_ repository for a full sample project +-- just swap out ``add_subdirectory`` for ``find_package``. + +.. _Config file: https://github.com/pybind/pybind11/blob/master/tools/pybind11Config.cmake.in + + +.. _find-python-mode: + +FindPython mode +--------------- + +CMake 3.12+ (3.15+ recommended, 3.18.2+ ideal) added a new module called +FindPython that had a highly improved search algorithm and modern targets +and tools. If you use FindPython, pybind11 will detect this and use the +existing targets instead: + +.. code-block:: cmake + + cmake_minimum_required(VERSION 3.15...3.22) + project(example LANGUAGES CXX) + + find_package(Python 3.6 COMPONENTS Interpreter Development REQUIRED) + find_package(pybind11 CONFIG REQUIRED) + # or add_subdirectory(pybind11) + + pybind11_add_module(example example.cpp) + +You can also use the targets (as listed below) with FindPython. If you define +``PYBIND11_FINDPYTHON``, pybind11 will perform the FindPython step for you +(mostly useful when building pybind11's own tests, or as a way to change search +algorithms from the CMake invocation, with ``-DPYBIND11_FINDPYTHON=ON``. + +.. warning:: + + If you use FindPython to multi-target Python versions, use the individual + targets listed below, and avoid targets that directly include Python parts. + +There are `many ways to hint or force a discovery of a specific Python +installation `_), +setting ``Python_ROOT_DIR`` may be the most common one (though with +virtualenv/venv support, and Conda support, this tends to find the correct +Python version more often than the old system did). + +.. warning:: + + When the Python libraries (i.e. ``libpythonXX.a`` and ``libpythonXX.so`` + on Unix) are not available, as is the case on a manylinux image, the + ``Development`` component will not be resolved by ``FindPython``. When not + using the embedding functionality, CMake 3.18+ allows you to specify + ``Development.Module`` instead of ``Development`` to resolve this issue. + +.. versionadded:: 2.6 + +Advanced: interface library targets +----------------------------------- + +Pybind11 supports modern CMake usage patterns with a set of interface targets, +available in all modes. The targets provided are: + + ``pybind11::headers`` + Just the pybind11 headers and minimum compile requirements + + ``pybind11::pybind11`` + Python headers + ``pybind11::headers`` + + ``pybind11::python_link_helper`` + Just the "linking" part of pybind11:module + + ``pybind11::module`` + Everything for extension modules - ``pybind11::pybind11`` + ``Python::Module`` (FindPython CMake 3.15+) or ``pybind11::python_link_helper`` + + ``pybind11::embed`` + Everything for embedding the Python interpreter - ``pybind11::pybind11`` + ``Python::Python`` (FindPython) or Python libs + + ``pybind11::lto`` / ``pybind11::thin_lto`` + An alternative to `INTERPROCEDURAL_OPTIMIZATION` for adding link-time optimization. + + ``pybind11::windows_extras`` + ``/bigobj`` and ``/mp`` for MSVC. + + ``pybind11::opt_size`` + ``/Os`` for MSVC, ``-Os`` for other compilers. Does nothing for debug builds. + +Two helper functions are also provided: + + ``pybind11_strip(target)`` + Strips a target (uses ``CMAKE_STRIP`` after the target is built) + + ``pybind11_extension(target)`` + Sets the correct extension (with SOABI) for a target. + +You can use these targets to build complex applications. For example, the +``add_python_module`` function is identical to: + +.. code-block:: cmake + + cmake_minimum_required(VERSION 3.5...3.26) + project(example LANGUAGES CXX) + + find_package(pybind11 REQUIRED) # or add_subdirectory(pybind11) + + add_library(example MODULE main.cpp) + + target_link_libraries(example PRIVATE pybind11::module pybind11::lto pybind11::windows_extras) + + pybind11_extension(example) + if(NOT MSVC AND NOT ${CMAKE_BUILD_TYPE} MATCHES Debug|RelWithDebInfo) + # Strip unnecessary sections of the binary on Linux/macOS + pybind11_strip(example) + endif() + + set_target_properties(example PROPERTIES CXX_VISIBILITY_PRESET "hidden" + CUDA_VISIBILITY_PRESET "hidden") + +Instead of setting properties, you can set ``CMAKE_*`` variables to initialize these correctly. + +.. warning:: + + Since pybind11 is a metatemplate library, it is crucial that certain + compiler flags are provided to ensure high quality code generation. In + contrast to the ``pybind11_add_module()`` command, the CMake interface + provides a *composable* set of targets to ensure that you retain flexibility. + It can be especially important to provide or set these properties; the + :ref:`FAQ ` contains an explanation on why these are needed. + +.. versionadded:: 2.6 + +.. _nopython-mode: + +Advanced: NOPYTHON mode +----------------------- + +If you want complete control, you can set ``PYBIND11_NOPYTHON`` to completely +disable Python integration (this also happens if you run ``FindPython2`` and +``FindPython3`` without running ``FindPython``). This gives you complete +freedom to integrate into an existing system (like `Scikit-Build's +`_ ``PythonExtensions``). +``pybind11_add_module`` and ``pybind11_extension`` will be unavailable, and the +targets will be missing any Python specific behavior. + +.. versionadded:: 2.6 + +Embedding the Python interpreter +-------------------------------- + +In addition to extension modules, pybind11 also supports embedding Python into +a C++ executable or library. In CMake, simply link with the ``pybind11::embed`` +target. It provides everything needed to get the interpreter running. The Python +headers and libraries are attached to the target. Unlike ``pybind11::module``, +there is no need to manually set any additional properties here. For more +information about usage in C++, see :doc:`/advanced/embedding`. + +.. code-block:: cmake + + cmake_minimum_required(VERSION 3.5...3.26) + project(example LANGUAGES CXX) + + find_package(pybind11 REQUIRED) # or add_subdirectory(pybind11) + + add_executable(example main.cpp) + target_link_libraries(example PRIVATE pybind11::embed) + +.. _building_manually: + +Building manually +================= + +pybind11 is a header-only library, hence it is not necessary to link against +any special libraries and there are no intermediate (magic) translation steps. + +On Linux, you can compile an example such as the one given in +:ref:`simple_example` using the following command: + +.. code-block:: bash + + $ c++ -O3 -Wall -shared -std=c++11 -fPIC $(python3 -m pybind11 --includes) example.cpp -o example$(python3-config --extension-suffix) + +The ``python3 -m pybind11 --includes`` command fetches the include paths for +both pybind11 and Python headers. This assumes that pybind11 has been installed +using ``pip`` or ``conda``. If it hasn't, you can also manually specify +``-I /include`` together with the Python includes path +``python3-config --includes``. + +On macOS: the build command is almost the same but it also requires passing +the ``-undefined dynamic_lookup`` flag so as to ignore missing symbols when +building the module: + +.. code-block:: bash + + $ c++ -O3 -Wall -shared -std=c++11 -undefined dynamic_lookup $(python3 -m pybind11 --includes) example.cpp -o example$(python3-config --extension-suffix) + +In general, it is advisable to include several additional build parameters +that can considerably reduce the size of the created binary. Refer to section +:ref:`cmake` for a detailed example of a suitable cross-platform CMake-based +build system that works on all platforms including Windows. + +.. note:: + + On Linux and macOS, it's better to (intentionally) not link against + ``libpython``. The symbols will be resolved when the extension library + is loaded into a Python binary. This is preferable because you might + have several different installations of a given Python version (e.g. the + system-provided Python, and one that ships with a piece of commercial + software). In this way, the plugin will work with both versions, instead + of possibly importing a second Python library into a process that already + contains one (which will lead to a segfault). + + +Building with Bazel +=================== + +You can build with the Bazel build system using the `pybind11_bazel +`_ repository. + +Generating binding code automatically +===================================== + +The ``Binder`` project is a tool for automatic generation of pybind11 binding +code by introspecting existing C++ codebases using LLVM/Clang. See the +[binder]_ documentation for details. + +.. [binder] http://cppbinder.readthedocs.io/en/latest/about.html + +[AutoWIG]_ is a Python library that wraps automatically compiled libraries into +high-level languages. It parses C++ code using LLVM/Clang technologies and +generates the wrappers using the Mako templating engine. The approach is automatic, +extensible, and applies to very complex C++ libraries, composed of thousands of +classes or incorporating modern meta-programming constructs. + +.. [AutoWIG] https://github.com/StatisKit/AutoWIG + +[robotpy-build]_ is a is a pure python, cross platform build tool that aims to +simplify creation of python wheels for pybind11 projects, and provide +cross-project dependency management. Additionally, it is able to autogenerate +customizable pybind11-based wrappers by parsing C++ header files. + +.. [robotpy-build] https://robotpy-build.readthedocs.io diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/conf.py b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/conf.py new file mode 100644 index 000000000..6e24751e9 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/conf.py @@ -0,0 +1,368 @@ +#!/usr/bin/env python3 +# +# pybind11 documentation build configuration file, created by +# sphinx-quickstart on Sun Oct 11 19:23:48 2015. +# +# This file is execfile()d with the current directory set to its +# containing dir. +# +# Note that not all possible configuration values are present in this +# autogenerated file. +# +# All configuration values have a default; values that are commented out +# serve to show the default. + +import os +import re +import subprocess +import sys +from pathlib import Path + +DIR = Path(__file__).parent.resolve() + +# If extensions (or modules to document with autodoc) are in another directory, +# add these directories to sys.path here. If the directory is relative to the +# documentation root, use os.path.abspath to make it absolute, like shown here. +# sys.path.insert(0, os.path.abspath('.')) + +# -- General configuration ------------------------------------------------ + +# If your documentation needs a minimal Sphinx version, state it here. +# needs_sphinx = '1.0' + +# Add any Sphinx extension module names here, as strings. They can be +# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom +# ones. +extensions = [ + "breathe", + "sphinx_copybutton", + "sphinxcontrib.rsvgconverter", + "sphinxcontrib.moderncmakedomain", +] + +breathe_projects = {"pybind11": ".build/doxygenxml/"} +breathe_default_project = "pybind11" +breathe_domain_by_extension = {"h": "cpp"} + +# Add any paths that contain templates here, relative to this directory. +templates_path = [".templates"] + +# The suffix(es) of source filenames. +# You can specify multiple suffix as a list of string: +# source_suffix = ['.rst', '.md'] +source_suffix = ".rst" + +# The encoding of source files. +# source_encoding = 'utf-8-sig' + +# The master toctree document. +master_doc = "index" + +# General information about the project. +project = "pybind11" +copyright = "2017, Wenzel Jakob" +author = "Wenzel Jakob" + +# The version info for the project you're documenting, acts as replacement for +# |version| and |release|, also used in various other places throughout the +# built documents. + +# Read the listed version +with open("../pybind11/_version.py") as f: + code = compile(f.read(), "../pybind11/_version.py", "exec") +loc = {} +exec(code, loc) + +# The full version, including alpha/beta/rc tags. +version = loc["__version__"] + +# The language for content autogenerated by Sphinx. Refer to documentation +# for a list of supported languages. +# +# This is also used if you do content translation via gettext catalogs. +# Usually you set "language" from the command line for these cases. +language = None + +# There are two options for replacing |today|: either, you set today to some +# non-false value, then it is used: +# today = '' +# Else, today_fmt is used as the format for a strftime call. +# today_fmt = '%B %d, %Y' + +# List of patterns, relative to source directory, that match files and +# directories to ignore when looking for source files. +exclude_patterns = [".build", "release.rst"] + +# The reST default role (used for this markup: `text`) to use for all +# documents. +default_role = "any" + +# If true, '()' will be appended to :func: etc. cross-reference text. +# add_function_parentheses = True + +# If true, the current module name will be prepended to all description +# unit titles (such as .. function::). +# add_module_names = True + +# If true, sectionauthor and moduleauthor directives will be shown in the +# output. They are ignored by default. +# show_authors = False + +# The name of the Pygments (syntax highlighting) style to use. +# pygments_style = 'monokai' + +# A list of ignored prefixes for module index sorting. +# modindex_common_prefix = [] + +# If true, keep warnings as "system message" paragraphs in the built documents. +# keep_warnings = False + +# If true, `todo` and `todoList` produce output, else they produce nothing. +todo_include_todos = False + + +# -- Options for HTML output ---------------------------------------------- + +# The theme to use for HTML and HTML Help pages. See the documentation for +# a list of builtin themes. + +html_theme = "furo" + +# Theme options are theme-specific and customize the look and feel of a theme +# further. For a list of options available for each theme, see the +# documentation. +# html_theme_options = {} + +# Add any paths that contain custom themes here, relative to this directory. +# html_theme_path = [] + +# The name for this set of Sphinx documents. If None, it defaults to +# " v documentation". +# html_title = None + +# A shorter title for the navigation bar. Default is the same as html_title. +# html_short_title = None + +# The name of an image file (relative to this directory) to place at the top +# of the sidebar. +# html_logo = None + +# The name of an image file (within the static path) to use as favicon of the +# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32 +# pixels large. +# html_favicon = None + +# Add any paths that contain custom static files (such as style sheets) here, +# relative to this directory. They are copied after the builtin static files, +# so a file named "default.css" will overwrite the builtin "default.css". +html_static_path = ["_static"] + +html_css_files = [ + "css/custom.css", +] + +# Add any extra paths that contain custom files (such as robots.txt or +# .htaccess) here, relative to this directory. These files are copied +# directly to the root of the documentation. +# html_extra_path = [] + +# If not '', a 'Last updated on:' timestamp is inserted at every page bottom, +# using the given strftime format. +# html_last_updated_fmt = '%b %d, %Y' + +# If true, SmartyPants will be used to convert quotes and dashes to +# typographically correct entities. +# html_use_smartypants = True + +# Custom sidebar templates, maps document names to template names. +# html_sidebars = {} + +# Additional templates that should be rendered to pages, maps page names to +# template names. +# html_additional_pages = {} + +# If false, no module index is generated. +# html_domain_indices = True + +# If false, no index is generated. +# html_use_index = True + +# If true, the index is split into individual pages for each letter. +# html_split_index = False + +# If true, links to the reST sources are added to the pages. +# html_show_sourcelink = True + +# If true, "Created using Sphinx" is shown in the HTML footer. Default is True. +# html_show_sphinx = True + +# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True. +# html_show_copyright = True + +# If true, an OpenSearch description file will be output, and all pages will +# contain a tag referring to it. The value of this option must be the +# base URL from which the finished HTML is served. +# html_use_opensearch = '' + +# This is the file name suffix for HTML files (e.g. ".xhtml"). +# html_file_suffix = None + +# Language to be used for generating the HTML full-text search index. +# Sphinx supports the following languages: +# 'da', 'de', 'en', 'es', 'fi', 'fr', 'h', 'it', 'ja' +# 'nl', 'no', 'pt', 'ro', 'r', 'sv', 'tr' +# html_search_language = 'en' + +# A dictionary with options for the search language support, empty by default. +# Now only 'ja' uses this config value +# html_search_options = {'type': 'default'} + +# The name of a javascript file (relative to the configuration directory) that +# implements a search results scorer. If empty, the default will be used. +# html_search_scorer = 'scorer.js' + +# Output file base name for HTML help builder. +htmlhelp_basename = "pybind11doc" + +# -- Options for LaTeX output --------------------------------------------- + +latex_engine = "pdflatex" + +latex_elements = { + # The paper size ('letterpaper' or 'a4paper'). + # 'papersize': 'letterpaper', + # + # The font size ('10pt', '11pt' or '12pt'). + # 'pointsize': '10pt', + # + # Additional stuff for the LaTeX preamble. + # remove blank pages (between the title page and the TOC, etc.) + "classoptions": ",openany,oneside", + "preamble": r""" +\usepackage{fontawesome} +\usepackage{textgreek} +\DeclareUnicodeCharacter{00A0}{} +\DeclareUnicodeCharacter{2194}{\faArrowsH} +\DeclareUnicodeCharacter{1F382}{\faBirthdayCake} +\DeclareUnicodeCharacter{1F355}{\faAdjust} +\DeclareUnicodeCharacter{0301}{'} +\DeclareUnicodeCharacter{03C0}{\textpi} + +""", + # Latex figure (float) alignment + # 'figure_align': 'htbp', +} + +# Grouping the document tree into LaTeX files. List of tuples +# (source start file, target name, title, +# author, documentclass [howto, manual, or own class]). +latex_documents = [ + (master_doc, "pybind11.tex", "pybind11 Documentation", "Wenzel Jakob", "manual"), +] + +# The name of an image file (relative to this directory) to place at the top of +# the title page. +# latex_logo = 'pybind11-logo.png' + +# For "manual" documents, if this is true, then toplevel headings are parts, +# not chapters. +# latex_use_parts = False + +# If true, show page references after internal links. +# latex_show_pagerefs = False + +# If true, show URL addresses after external links. +# latex_show_urls = False + +# Documents to append as an appendix to all manuals. +# latex_appendices = [] + +# If false, no module index is generated. +# latex_domain_indices = True + + +# -- Options for manual page output --------------------------------------- + +# One entry per manual page. List of tuples +# (source start file, name, description, authors, manual section). +man_pages = [(master_doc, "pybind11", "pybind11 Documentation", [author], 1)] + +# If true, show URL addresses after external links. +# man_show_urls = False + + +# -- Options for Texinfo output ------------------------------------------- + +# Grouping the document tree into Texinfo files. List of tuples +# (source start file, target name, title, author, +# dir menu entry, description, category) +texinfo_documents = [ + ( + master_doc, + "pybind11", + "pybind11 Documentation", + author, + "pybind11", + "One line description of project.", + "Miscellaneous", + ), +] + +# Documents to append as an appendix to all manuals. +# texinfo_appendices = [] + +# If false, no module index is generated. +# texinfo_domain_indices = True + +# How to display URL addresses: 'footnote', 'no', or 'inline'. +# texinfo_show_urls = 'footnote' + +# If true, do not generate a @detailmenu in the "Top" node's menu. +# texinfo_no_detailmenu = False + +primary_domain = "cpp" +highlight_language = "cpp" + + +def generate_doxygen_xml(app): + build_dir = os.path.join(app.confdir, ".build") + if not os.path.exists(build_dir): + os.mkdir(build_dir) + + try: + subprocess.call(["doxygen", "--version"]) + retcode = subprocess.call(["doxygen"], cwd=app.confdir) + if retcode < 0: + sys.stderr.write(f"doxygen error code: {-retcode}\n") + except OSError as e: + sys.stderr.write(f"doxygen execution failed: {e}\n") + + +def prepare(app): + with open(DIR.parent / "README.rst") as f: + contents = f.read() + + if app.builder.name == "latex": + # Remove badges and stuff from start + contents = contents[contents.find(r".. start") :] + + # Filter out section titles for index.rst for LaTeX + contents = re.sub(r"^(.*)\n[-~]{3,}$", r"**\1**", contents, flags=re.MULTILINE) + + with open(DIR / "readme.rst", "w") as f: + f.write(contents) + + +def clean_up(app, exception): # noqa: ARG001 + (DIR / "readme.rst").unlink() + + +def setup(app): + # Add hook for building doxygen xml when needed + app.connect("builder-inited", generate_doxygen_xml) + + # Copy the readme in + app.connect("builder-inited", prepare) + + # Clean up the generated readme + app.connect("build-finished", clean_up) diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/faq.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/faq.rst new file mode 100644 index 000000000..1eb00efad --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/faq.rst @@ -0,0 +1,308 @@ +Frequently asked questions +########################## + +"ImportError: dynamic module does not define init function" +=========================================================== + +1. Make sure that the name specified in PYBIND11_MODULE is identical to the +filename of the extension library (without suffixes such as ``.so``). + +2. If the above did not fix the issue, you are likely using an incompatible +version of Python that does not match what you compiled with. + +"Symbol not found: ``__Py_ZeroStruct`` / ``_PyInstanceMethod_Type``" +======================================================================== + +See the first answer. + +"SystemError: dynamic module not initialized properly" +====================================================== + +See the first answer. + +The Python interpreter immediately crashes when importing my module +=================================================================== + +See the first answer. + +.. _faq_reference_arguments: + +Limitations involving reference arguments +========================================= + +In C++, it's fairly common to pass arguments using mutable references or +mutable pointers, which allows both read and write access to the value +supplied by the caller. This is sometimes done for efficiency reasons, or to +realize functions that have multiple return values. Here are two very basic +examples: + +.. code-block:: cpp + + void increment(int &i) { i++; } + void increment_ptr(int *i) { (*i)++; } + +In Python, all arguments are passed by reference, so there is no general +issue in binding such code from Python. + +However, certain basic Python types (like ``str``, ``int``, ``bool``, +``float``, etc.) are **immutable**. This means that the following attempt +to port the function to Python doesn't have the same effect on the value +provided by the caller -- in fact, it does nothing at all. + +.. code-block:: python + + def increment(i): + i += 1 # nope.. + +pybind11 is also affected by such language-level conventions, which means that +binding ``increment`` or ``increment_ptr`` will also create Python functions +that don't modify their arguments. + +Although inconvenient, one workaround is to encapsulate the immutable types in +a custom type that does allow modifications. + +An other alternative involves binding a small wrapper lambda function that +returns a tuple with all output arguments (see the remainder of the +documentation for examples on binding lambda functions). An example: + +.. code-block:: cpp + + int foo(int &i) { i++; return 123; } + +and the binding code + +.. code-block:: cpp + + m.def("foo", [](int i) { int rv = foo(i); return std::make_tuple(rv, i); }); + + +How can I reduce the build time? +================================ + +It's good practice to split binding code over multiple files, as in the +following example: + +:file:`example.cpp`: + +.. code-block:: cpp + + void init_ex1(py::module_ &); + void init_ex2(py::module_ &); + /* ... */ + + PYBIND11_MODULE(example, m) { + init_ex1(m); + init_ex2(m); + /* ... */ + } + +:file:`ex1.cpp`: + +.. code-block:: cpp + + void init_ex1(py::module_ &m) { + m.def("add", [](int a, int b) { return a + b; }); + } + +:file:`ex2.cpp`: + +.. code-block:: cpp + + void init_ex2(py::module_ &m) { + m.def("sub", [](int a, int b) { return a - b; }); + } + +:command:`python`: + +.. code-block:: pycon + + >>> import example + >>> example.add(1, 2) + 3 + >>> example.sub(1, 1) + 0 + +As shown above, the various ``init_ex`` functions should be contained in +separate files that can be compiled independently from one another, and then +linked together into the same final shared object. Following this approach +will: + +1. reduce memory requirements per compilation unit. + +2. enable parallel builds (if desired). + +3. allow for faster incremental builds. For instance, when a single class + definition is changed, only a subset of the binding code will generally need + to be recompiled. + +"recursive template instantiation exceeded maximum depth of 256" +================================================================ + +If you receive an error about excessive recursive template evaluation, try +specifying a larger value, e.g. ``-ftemplate-depth=1024`` on GCC/Clang. The +culprit is generally the generation of function signatures at compile time +using C++14 template metaprogramming. + +.. _`faq:hidden_visibility`: + +"'SomeClass' declared with greater visibility than the type of its field 'SomeClass::member' [-Wattributes]" +============================================================================================================ + +This error typically indicates that you are compiling without the required +``-fvisibility`` flag. pybind11 code internally forces hidden visibility on +all internal code, but if non-hidden (and thus *exported*) code attempts to +include a pybind type (for example, ``py::object`` or ``py::list``) you can run +into this warning. + +To avoid it, make sure you are specifying ``-fvisibility=hidden`` when +compiling pybind code. + +As to why ``-fvisibility=hidden`` is necessary, because pybind modules could +have been compiled under different versions of pybind itself, it is also +important that the symbols defined in one module do not clash with the +potentially-incompatible symbols defined in another. While Python extension +modules are usually loaded with localized symbols (under POSIX systems +typically using ``dlopen`` with the ``RTLD_LOCAL`` flag), this Python default +can be changed, but even if it isn't it is not always enough to guarantee +complete independence of the symbols involved when not using +``-fvisibility=hidden``. + +Additionally, ``-fvisibility=hidden`` can deliver considerably binary size +savings. (See the following section for more details.) + + +.. _`faq:symhidden`: + +How can I create smaller binaries? +================================== + +To do its job, pybind11 extensively relies on a programming technique known as +*template metaprogramming*, which is a way of performing computation at compile +time using type information. Template metaprogramming usually instantiates code +involving significant numbers of deeply nested types that are either completely +removed or reduced to just a few instructions during the compiler's optimization +phase. However, due to the nested nature of these types, the resulting symbol +names in the compiled extension library can be extremely long. For instance, +the included test suite contains the following symbol: + +.. only:: html + + .. code-block:: none + + _​_​Z​N​8​p​y​b​i​n​d​1​1​1​2​c​p​p​_​f​u​n​c​t​i​o​n​C​1​I​v​8​E​x​a​m​p​l​e​2​J​R​N​S​t​3​_​_​1​6​v​e​c​t​o​r​I​N​S​3​_​1​2​b​a​s​i​c​_​s​t​r​i​n​g​I​w​N​S​3​_​1​1​c​h​a​r​_​t​r​a​i​t​s​I​w​E​E​N​S​3​_​9​a​l​l​o​c​a​t​o​r​I​w​E​E​E​E​N​S​8​_​I​S​A​_​E​E​E​E​E​J​N​S​_​4​n​a​m​e​E​N​S​_​7​s​i​b​l​i​n​g​E​N​S​_​9​i​s​_​m​e​t​h​o​d​E​A​2​8​_​c​E​E​E​M​T​0​_​F​T​_​D​p​T​1​_​E​D​p​R​K​T​2​_ + +.. only:: not html + + .. code-block:: cpp + + __ZN8pybind1112cpp_functionC1Iv8Example2JRNSt3__16vectorINS3_12basic_stringIwNS3_11char_traitsIwEENS3_9allocatorIwEEEENS8_ISA_EEEEEJNS_4nameENS_7siblingENS_9is_methodEA28_cEEEMT0_FT_DpT1_EDpRKT2_ + +which is the mangled form of the following function type: + +.. code-block:: cpp + + pybind11::cpp_function::cpp_function, std::__1::allocator >, std::__1::allocator, std::__1::allocator > > >&, pybind11::name, pybind11::sibling, pybind11::is_method, char [28]>(void (Example2::*)(std::__1::vector, std::__1::allocator >, std::__1::allocator, std::__1::allocator > > >&), pybind11::name const&, pybind11::sibling const&, pybind11::is_method const&, char const (&) [28]) + +The memory needed to store just the mangled name of this function (196 bytes) +is larger than the actual piece of code (111 bytes) it represents! On the other +hand, it's silly to even give this function a name -- after all, it's just a +tiny cog in a bigger piece of machinery that is not exposed to the outside +world. So we'll generally only want to export symbols for those functions which +are actually called from the outside. + +This can be achieved by specifying the parameter ``-fvisibility=hidden`` to GCC +and Clang, which sets the default symbol visibility to *hidden*, which has a +tremendous impact on the final binary size of the resulting extension library. +(On Visual Studio, symbols are already hidden by default, so nothing needs to +be done there.) + +In addition to decreasing binary size, ``-fvisibility=hidden`` also avoids +potential serious issues when loading multiple modules and is required for +proper pybind operation. See the previous FAQ entry for more details. + +How can I properly handle Ctrl-C in long-running functions? +=========================================================== + +Ctrl-C is received by the Python interpreter, and holds it until the GIL +is released, so a long-running function won't be interrupted. + +To interrupt from inside your function, you can use the ``PyErr_CheckSignals()`` +function, that will tell if a signal has been raised on the Python side. This +function merely checks a flag, so its impact is negligible. When a signal has +been received, you must either explicitly interrupt execution by throwing +``py::error_already_set`` (which will propagate the existing +``KeyboardInterrupt``), or clear the error (which you usually will not want): + +.. code-block:: cpp + + PYBIND11_MODULE(example, m) + { + m.def("long running_func", []() + { + for (;;) { + if (PyErr_CheckSignals() != 0) + throw py::error_already_set(); + // Long running iteration + } + }); + } + +CMake doesn't detect the right Python version +============================================= + +The CMake-based build system will try to automatically detect the installed +version of Python and link against that. When this fails, or when there are +multiple versions of Python and it finds the wrong one, delete +``CMakeCache.txt`` and then add ``-DPYTHON_EXECUTABLE=$(which python)`` to your +CMake configure line. (Replace ``$(which python)`` with a path to python if +your prefer.) + +You can alternatively try ``-DPYBIND11_FINDPYTHON=ON``, which will activate the +new CMake FindPython support instead of pybind11's custom search. Requires +CMake 3.12+, and 3.15+ or 3.18.2+ are even better. You can set this in your +``CMakeLists.txt`` before adding or finding pybind11, as well. + +Inconsistent detection of Python version in CMake and pybind11 +============================================================== + +The functions ``find_package(PythonInterp)`` and ``find_package(PythonLibs)`` +provided by CMake for Python version detection are modified by pybind11 due to +unreliability and limitations that make them unsuitable for pybind11's needs. +Instead pybind11 provides its own, more reliable Python detection CMake code. +Conflicts can arise, however, when using pybind11 in a project that *also* uses +the CMake Python detection in a system with several Python versions installed. + +This difference may cause inconsistencies and errors if *both* mechanisms are +used in the same project. + +There are three possible solutions: + +1. Avoid using ``find_package(PythonInterp)`` and ``find_package(PythonLibs)`` + from CMake and rely on pybind11 in detecting Python version. If this is not + possible, the CMake machinery should be called *before* including pybind11. +2. Set ``PYBIND11_FINDPYTHON`` to ``True`` or use ``find_package(Python + COMPONENTS Interpreter Development)`` on modern CMake (3.12+, 3.15+ better, + 3.18.2+ best). Pybind11 in these cases uses the new CMake FindPython instead + of the old, deprecated search tools, and these modules are much better at + finding the correct Python. If FindPythonLibs/Interp are not available + (CMake 3.27+), then this will be ignored and FindPython will be used. +3. Set ``PYBIND11_NOPYTHON`` to ``TRUE``. Pybind11 will not search for Python. + However, you will have to use the target-based system, and do more setup + yourself, because it does not know about or include things that depend on + Python, like ``pybind11_add_module``. This might be ideal for integrating + into an existing system, like scikit-build's Python helpers. + +How to cite this project? +========================= + +We suggest the following BibTeX template to cite pybind11 in scientific +discourse: + +.. code-block:: bash + + @misc{pybind11, + author = {Wenzel Jakob and Jason Rhinelander and Dean Moldovan}, + year = {2017}, + note = {https://github.com/pybind/pybind11}, + title = {pybind11 -- Seamless operability between C++11 and Python} + } diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/index.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/index.rst new file mode 100644 index 000000000..4e2e8ca3a --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/index.rst @@ -0,0 +1,48 @@ +.. only:: latex + + Intro + ===== + +.. include:: readme.rst + +.. only:: not latex + + Contents: + +.. toctree:: + :maxdepth: 1 + + changelog + upgrade + +.. toctree:: + :caption: The Basics + :maxdepth: 2 + + installing + basics + classes + compiling + +.. toctree:: + :caption: Advanced Topics + :maxdepth: 2 + + advanced/functions + advanced/classes + advanced/exceptions + advanced/smart_ptrs + advanced/cast/index + advanced/pycpp/index + advanced/embedding + advanced/misc + +.. toctree:: + :caption: Extra Information + :maxdepth: 1 + + faq + benchmark + limitations + reference + cmake/index diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/installing.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/installing.rst new file mode 100644 index 000000000..30b9f1853 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/installing.rst @@ -0,0 +1,105 @@ +.. _installing: + +Installing the library +###################### + +There are several ways to get the pybind11 source, which lives at +`pybind/pybind11 on GitHub `_. The pybind11 +developers recommend one of the first three ways listed here, submodule, PyPI, +or conda-forge, for obtaining pybind11. + +.. _include_as_a_submodule: + +Include as a submodule +====================== + +When you are working on a project in Git, you can use the pybind11 repository +as a submodule. From your git repository, use: + +.. code-block:: bash + + git submodule add -b stable ../../pybind/pybind11 extern/pybind11 + git submodule update --init + +This assumes you are placing your dependencies in ``extern/``, and that you are +using GitHub; if you are not using GitHub, use the full https or ssh URL +instead of the relative URL ``../../pybind/pybind11`` above. Some other servers +also require the ``.git`` extension (GitHub does not). + +From here, you can now include ``extern/pybind11/include``, or you can use +the various integration tools (see :ref:`compiling`) pybind11 provides directly +from the local folder. + +Include with PyPI +================= + +You can download the sources and CMake files as a Python package from PyPI +using Pip. Just use: + +.. code-block:: bash + + pip install pybind11 + +This will provide pybind11 in a standard Python package format. If you want +pybind11 available directly in your environment root, you can use: + +.. code-block:: bash + + pip install "pybind11[global]" + +This is not recommended if you are installing with your system Python, as it +will add files to ``/usr/local/include/pybind11`` and +``/usr/local/share/cmake/pybind11``, so unless that is what you want, it is +recommended only for use in virtual environments or your ``pyproject.toml`` +file (see :ref:`compiling`). + +Include with conda-forge +======================== + +You can use pybind11 with conda packaging via `conda-forge +`_: + +.. code-block:: bash + + conda install -c conda-forge pybind11 + + +Include with vcpkg +================== +You can download and install pybind11 using the Microsoft `vcpkg +`_ dependency manager: + +.. code-block:: bash + + git clone https://github.com/Microsoft/vcpkg.git + cd vcpkg + ./bootstrap-vcpkg.sh + ./vcpkg integrate install + vcpkg install pybind11 + +The pybind11 port in vcpkg is kept up to date by Microsoft team members and +community contributors. If the version is out of date, please `create an issue +or pull request `_ on the vcpkg +repository. + +Global install with brew +======================== + +The brew package manager (Homebrew on macOS, or Linuxbrew on Linux) has a +`pybind11 package +`_. +To install: + +.. code-block:: bash + + brew install pybind11 + +.. We should list Conan, and possibly a few other C++ package managers (hunter, +.. perhaps). Conan has a very clean CMake integration that would be good to show. + +Other options +============= + +Other locations you can find pybind11 are `listed here +`_; these are maintained +by various packagers and the community. diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/limitations.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/limitations.rst new file mode 100644 index 000000000..def5ad659 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/limitations.rst @@ -0,0 +1,72 @@ +Limitations +########### + +Design choices +^^^^^^^^^^^^^^ + +pybind11 strives to be a general solution to binding generation, but it also has +certain limitations: + +- pybind11 casts away ``const``-ness in function arguments and return values. + This is in line with the Python language, which has no concept of ``const`` + values. This means that some additional care is needed to avoid bugs that + would be caught by the type checker in a traditional C++ program. + +- The NumPy interface ``pybind11::array`` greatly simplifies accessing + numerical data from C++ (and vice versa), but it's not a full-blown array + class like ``Eigen::Array`` or ``boost.multi_array``. ``Eigen`` objects are + directly supported, however, with ``pybind11/eigen.h``. + +Large but useful features could be implemented in pybind11 but would lead to a +significant increase in complexity. Pybind11 strives to be simple and compact. +Users who require large new features are encouraged to write an extension to +pybind11; see `pybind11_json `_ for an +example. + + +Known bugs +^^^^^^^^^^ + +These are issues that hopefully will one day be fixed, but currently are +unsolved. If you know how to help with one of these issues, contributions +are welcome! + +- Intel 20.2 is currently having an issue with the test suite. + `#2573 `_ + +- Debug mode Python does not support 1-5 tests in the test suite currently. + `#2422 `_ + +- PyPy3 7.3.1 and 7.3.2 have issues with several tests on 32-bit Windows. + +Known limitations +^^^^^^^^^^^^^^^^^ + +These are issues that are probably solvable, but have not been fixed yet. A +clean, well written patch would likely be accepted to solve them. + +- Type casters are not kept alive recursively. + `#2527 `_ + One consequence is that containers of ``char *`` are currently not supported. + `#2245 `_ + +- The ``cpptest`` does not run on Windows with Python 3.8 or newer, due to DLL + loader changes. User code that is correctly installed should not be affected. + `#2560 `_ + +Python 3.9.0 warning +^^^^^^^^^^^^^^^^^^^^ + +Combining older versions of pybind11 (< 2.6.0) with Python on exactly 3.9.0 +will trigger undefined behavior that typically manifests as crashes during +interpreter shutdown (but could also destroy your data. **You have been +warned**). + +This issue was `fixed in Python `_. +As a mitigation for this bug, pybind11 2.6.0 or newer includes a workaround +specifically when Python 3.9.0 is detected at runtime, leaking about 50 bytes +of memory when a callback function is garbage collected. For reference, the +pybind11 test suite has about 2,000 such callbacks, but only 49 are garbage +collected before the end-of-process. Wheels (even if built with Python 3.9.0) +will correctly avoid the leak when run in Python 3.9.1, and this does not +affect other 3.X versions. diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/pybind11-logo.png b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/pybind11-logo.png new file mode 100644 index 0000000000000000000000000000000000000000..2d633a4d0c129d6bdd94b4134c9516fdc92bb192 GIT binary patch literal 61034 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 literal 0 HcmV?d00001 diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/pybind11_vs_boost_python1.png b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/pybind11_vs_boost_python1.png new file mode 100644 index 0000000000000000000000000000000000000000..833231f240809884fb6eb4079db528b9b3c0a9ac GIT binary patch literal 44653 zcmcG$2UJsC+by~S0ty0#-ob!0=^(vo5G*tyf`Ficf<(IX7WG9sm=~2^M5TnLV(3kf zqLhFLNUs_YA@oSUEBJlqd;fFpx%d9}j=LSh0TGhD*LupF^O?&iQ)2^0dLDWRf*3Ct zBCkLYH35RC7?09|SD;a&cJMdttxE<-=z#JkyDl#gf`p(8NIeVx^j~8^!M3+Ebe0L^ zluJApUr4)3+^xi8Mvqunu(97i?d46A)QB_va{ou?doHD#>gxSkJ`bPb!V!I?Pw5v% z+Vw4+*q_BrvXAM*3&`}ZM~5FjMT=o`@BXbuAd}lVpWc-*`XZ{9*iGCETyaq#su8z3 z9gW-lGKrdWLWuvym0BV)2O%v&Q&UrML4kqsjNxY`5dPa2N(3|6pE2q+eA!gWb95G=j()kE$JV(bGl z{kk3q5Iob{pw9OL`{!(IMjp{+K8cJJSDnhHK4G@Z5`}b-NwQ(gu3qkeFs=|2%^RpO z4XXX*nI86QaWQ0~xMF;m)%5FylZc1{7e-9LBV}nS2<^JAyW??PWprq0>l$?MwBvg` zwW)e)m@0+`r8TX)lj1yh-ER!Ox3{NK_%lGfR^ZeRSUyY+{WFoq05v%MtZD1mtj>)s z2ahPx_((pc8}gVu(YYsQpgYlq{YUr{!0pLNWkyNbBCx-caiK8CVgm-bSy~Pf6jNfE zXAOodHdt}h^o=!zg@p}FlhKf{i7I+A3puL{g(Vkhm){#w5Mzl74*sjFf!ZT2a`(== z?FsuT+ocV}sy3AIs3NM}1k%jIg{5pee#kE@jKTe!fMIZUNyd3;kGhfIGJn*fXhsv$ zHdAWZPvETIYt7M*De<|kVmX|P$8T^$gQr-cI8hsY(EdrRVXelqi(_ivABbI0&)A1y z1dsGL5CgcOlx*;!nZywJx#Q-p-RWu(FP0CwJye6;8$BZy(C9YzNPbRJiL5S!>uJGgmd;cdW`{ zh1cYvc!k!#it)1jU%zVps4mI)E0hW5@ec2sE1wG@POP=s-N9kzCfGc&t$M+dl9K&} zE|rPhim2`i*|%1|4B^+PvV(ea^wVe?2p}FWv?dE%_>>U?WaE8n9Tlo{QAzo@MG|S^ z>-hM%Pd2w@k(KAeNIrI^2*1tsbxq|jua6B3Kar<}CU-(f`4dcc0L=vvtXfv78z_=%><*6pqQ`ExIN9HgbChlIRNz~OO^86Lw?`HvqzPW4b7 zh3Q&sG|%7P&h6cdYMUXkV1!!Drk`be3k(+x?Pxc2zBZ&v+-gJd{#3^HI2 zOtGU{?gw=z>@-JI{LCoRgEZ4RzK?T7A?u59gHW=WvjQZ<8igzoT%KY=7H5@I#UBVu0g;qTwA9v{7!)?Ebw6*zNRnLo&;443eWC3+3 z(@`Oy1g}gp`TkZGVl|tzLvlx>dA+(^H3h;HF|yI^X)B+1K5}9Oc^tIAeEIV3u06qt zizT7W0kK;8EeKmXhFImFAnVu#hk<7%M4o?{5l-~I0Vhv{x7|DtyrKMTdQK$`l)OFfye`zlj3_)H@^-=cpGc#o__MVwe-wk=hKr$@xWFu2=&R!5 zMeLNF2`Kv6$-QYOdOwJ>(JyX2!Y|Y9<$sx94*|LF;4$?}wR@x(&kU(c*sK*V~?**#Z zAU>K&JCrM`-<|54b^BIIcXu}->DSs3jLxDOracR~_hx{@;Ic4u#|lmUslySIaVvI< zA48`8#yHskd!PUF9K;dRZr$d2<@HYT?wdJ2Xsu~#`8tk=Zux!Ws9F07*z&%uj33?k z18BnpQs%4|fZo6wAJ^B{heG1B8D^@YkPshJ#FK+60mjLs@TRQ;Xf$q@jscI`9`o1S zhoKh<5Fg6_V2^L>>9~>379-C#F zNO#euu(2aqjYu5hzK^(NF_xVs8^Jd$rX8uOw z^pl~G7~42eho*;lasvvT1l<*Nh9=t*)sV2e;Er^>W@17hUSyuDcJtr-H8dd+Y-K?` z$r-*op|^jq7zK)I#I3hhuJfTA8yjUWd*@{7NilpF_mg2I+RQi3tQOWYzraPnk{x2X z@2=Fk%ue_z8U#o~(2D=AmqVwl#YQny9^JkOX+k5&*;@{sk0`P9mM;eM0G!9LvRSx7 z>sOp4v>uqLG7hiN`nj;+MEzTE_P~GN&fT5V-y%_3vXJVO8So&%Ke#7Q;xb|BMI9dR9`RfeKd zw>4x*9Vr~Pb9zIQ)Yp+Dnk!w-oGBpj$`7*{Z>e+-5qa6j2W)zxUB<8RxN!<@lw5BO__`hpZ&H00JK1lc37 zm8Ph$qm!oyYvXFUoDw8QNY)xXVHzAqU&g*DHh;69*0bt)=h6d#{!%-z&JA38$$OO z!il>w@G8#60%)JV(Wz|c7h}sM4!*XkV_WbsX6Sd`^aHS0DGAZ-LC|`1J3FObPM2Fr z`PRz+u!F>++KZuayHSp~^E!`q)hZYpM`HR8_}ii&XWA3IZEHiar>_>NUPab32}vU6 zK_)H4^mShH=5nY9&HBEVY2T-)$Vl3mc15#r$;Fn_M_+ zd+Tp((O70Gf2KxHEiJ7i=86et>+DV+{$T&qo^-?|yAb~|h>uGi_3{Y#&P0Uw-; z=Vy0&5tgd*_3eSC`;$Z{+apeiUQH)9f70TNomBdR-Fr;4PNKR`0E1$n@@3eG`jk;yP%KBKuTxMpoGH;V8~Z**Q)~v zYqal%e)+UWC4S=a)>^Gl*?EbxvkVL=Ck9XhLKW=L53dr!E8F=N>Mv1%V#<|U4;96^YQ zJGa9KY?b9B!F5gdq{!Vj%ZuU7xB26U0a=@x?k|V|pQg$SUFH`8=JwakRJ&=yWy8LV zj@G(XDh~`#F9hbys9vIVmmLkf*WL_e%G}er2NpUU$8;^OdX~67dvws2Q%6L+j<|U$ zJfuNuG{-j_`)N98?%{_Kx=W&oZ7|hiP^|pIV|1DC;;=Mg^<`7V&W0U#>*g2csEhX@ z-J9zBcA$oA20P!1O`(JM`T3oM4<0<*B$JubbTW(&V2#ZH!R?1bZ@h`!6(@Dhy&~nm zjIRz_)(&S56AkJ2gIB%!_8P3(qYBRGc|nfh`0X_j1R_;3z1+y+1#-5kDQRtU$m9Mc zNEdaWdW9OjD9CV{jWD;kSPV0*=6dSu=f|wFf&Xo=VOZ#sP^qAbnMip5!aoFulMyKB zvQmv_g=5Q#@p&=rg-^0_cU@*VzfnE0PuYU1#W|XV>q}xdqyt}-m6Zu@g@1g0qbL6b z&W-=(;PvoD#q-~^PXVy7V4P&_Q*_0+irP@pFe+|g^Z~9y3?hy7* z%`8}WS!BC6jvk((btSEr?W)PXB}%J$nTJD57%_3R|1_EWO&=F%HT6wcn{&{oct%yL zos-ZU*O*XAvhd&fp5zzz-U!*c?kzoPSv40c|I6#QGh-3HWw6}IzJmR9fFL7zcqsvH zpKvxzIFs(tFuQ$X$aoV#vR+dG0$0A3{>}^weHCJ{k@D8@n>}a~>EV`l>guYOC+cJW zx!0gZ5T4k7;BHNpH;Uuq;;Ph4>TvbpBd$0qT&sQ7Z48~j!t=yI@6e(#6=C7lMENyE zR2AVF&JSNzKm~l=ImVp##>HQ8wIYA}6o!|+;u~&7v-B!b`|3S_Z8vv(F|EnBZYoVL z{H!jKaH|-I51d#i@EyLJXY`TaYx1E0M*?lpo4jFse+MjN7rP^(x ze$TPiD=iWwtEWm z6_&mU`8GYw1vWWRp>-M!gW41u7hG5`cU z8NYccT-N>+BCAb%X=g#Tn~s6}EgZ)|euUevT>g#gF3C@P2;b(*Fm>oJZC93L43HM7!wUDoV zSKIaU^q4B1E&CoGCg_Sr2f6&EOovMj`r4WJ`nLcpmK-N{MG6XKVTw3V{#`%VeE06% z0G4nn3sfn8iIGBzt%dDz6XX(iiIFLIW&zqa)Rj;Qf*uoiH;w)D)lMHir!$x|`o+*%=iVHf=n?NKTV9L| zga_?*0erwE0~>%$c3CkUPa0giyAt=(=`XAD)#FX2sM`-72*#Zsq)uj>WCnGO=N-$s zGp?}EFI$evskqL6*|*J82Iwz5bwulH6J+vb%QLO9z8PZi>L9RBhL!&0p7Qu@bK0^b z-Mm^0;IT)z(EQ~^%hol`)^o_{ssuyP#2C@SEVClm6Z8H-A79_l7N4;%*UbMm6w#)e zygVxl4I!fsxQxv>V8M3o^4Yv)0 zS2bA&h0mx0+K|yZ1sR{a>GCFWR~A$KMgRFgsr|uOO@W5<$bGs-o%1hyz4_a!7`7G) z2;g}UVO4p6kSEZQbuQRl?N>p*>@@)Jv;_A9IXl)~I=Pb*`ISUC`aAUuI*>K$qc!R} z&E(4{nO=%>hhrxST%<9=`i=zr;Ns$94S!nzed7vZmAcI{lM@>TczVV0 z!K8)iDi96N@S9@L`1H=cL;TFHF4C8cKIYbk`-Q}S;%0sagcVxlq|P?qy8-R*s@+WR z087bdJf7^!QO}L@4klHNSyu&FYzK#i0$$9hl5sfc+NBm|VYhWnl8S>`E-}DPQ$WWA zIi81`@Z=*Bp-{RTOsg+T4IqC#WQk-QvuD)_Y#5z~%xcAt?I`dDu-^=rmqmDz-oEx{ zn~;exor?qP`8eD*d4GT3FaM`aoIF`0evKa*L2VQxR%sz#tPYWUtJswTi-t*oTbx$y zu7mCY_M`!In)ka$w4i{>K{2P)1gq>`S4uPvNmr5NcZw(9#Ou1E@ zM2lw+LL^!FVwP}c6OxgKa2;@C7G%kej z6Vkago{baK1GjP+#ZOp!ev^gc`sr0ol0I~BB%5xF+=Ruczp6~V2WUPDC9Aiu?05;X zwFF8D&z4PAe^4ede&$K4ah?t|c@8QUK1khH#Lz;Du+clQ0bLfMhH?Vo8^>hWu_mx~ zDxeJ*z-;4ocRFH_h*Eydi~|aJSy))8fx>%(Arjp(0payLa`eb#V)F)2DPt-Y1KGBk zYMB~QP#~;!kZY}YW!B{Nm10PS1ikO+=IY}9R~JQCE}&dt%Qk?Efyn#F zwU%ltV@Wgl7Vu5td5u=9>)u^w6bo^<=WOSbDrBwS&tXHxHuKwk#+J(n+BPw}T8}Fd zZVOI6%eo}a7R_}0`2C{mHJisS-|E%0a&U0yFS%Y5&w))6TlEYlb}aDNm1}0(dD_a!Vj;whv451uU>Hg^m{+NV%EKiv|~~~`sdaEzyI!i z^>;S)(=>n0dNZUKUl8m+8tr1qvF!5>kkcY!}(HOU@^HXLILG^YNowPhhwq zT4H?sP~^ElkGK^Fq9 zP|zu#xz~#IjKb|}VRWL~39V`KH+-{6oTxfsHu@FnV~EsHzP11$n$>zsZeJ8lbQdSj z2(-VY3{HT0@@dIiY7wN96VT0H&ZuU6%eqXb*yhP}K{PRs4y+iZy#rlEF}Hf+(H`H} zM2Of7-*vo8e-r3--~Bc18gx>a?f|`^hys{;)HY8=#!@tcIn{3YM9*JQ>IR9QW*>sm zK59YaB7{10amBP4Ul3ujHx^+b4S~-pqYi0MjqmHHKp3-tNaxizk=fBb}g$P#)B@Bni( zI4Y#P%lyKPY^7n~(9G((la&(dVDdG{cd98|wtoG~rIB3qHvdhHp4g8Qo=A%ixn9G{ zM#axgTgv$IIob87MLPQ@o-xXd6s0Bfe)@2C1ldOiKp+@qfb0B+=@iMc=H}*j(vBx2 z_~YSCR%{{6RGu+G7A{tz7HXW#WG(a zEqbjq&GoIy?ijgWzdq&yEo&wey0Sh?0SVk4$E#A3spc(8`e1DF7;FTPgIJ+|ughh2 z;lxktv>6W~A6r_bWD&*9Qa(E>X#2;rn1#>avnVqiaJ{^-a{13!O7zAfxzRlo*?nXr zh#mSmFfe{K8F3ML`_|U#_cb6f=_6LXKzk9M(?q^kY4ZdzN&q~90ECV#T0s59k4j}0 zApUB;=@5I3?>-ZP$4;CLr_d^Owf|nvwMb`iRL1StYxj!3gLSZYOL?d{aAj!)`OBF`}%Kd#9ig;W@@9xriuvNo0#k)T{t!qM^!GNwL3wOk2J zR7Ct$XQQ)Sl8F&!={<6D$`P#YME@L~ln${EI%yQerhbixS1VY(AK z@z=ZSH_LQ_*9ITZiAuApfzK=gk<@Pts{p%EamD<1r zn6k2bZk`i$?2UB}6Xyg=)m=Ui#H2w*Jw^#UQ_8$T#eMuO)I%A1^?;h-4jQu}0QKnL z2|_?-#TiQ6Re*8TH89Xy3z;BoXu1dW1blvQCij!o&K)Qs;mg;GCn&q=Uk?h}^^u7Y z!UPMr3mW~ho+P^#5|*-19XtUN$3s<Ow9BUWk!&#FfE&KLRlo^;d3g?$6B3%mkROkx^G%$-;29 zBE0uBko}A0MRRdO_titp4>t)k0V#OZWt2)@-~7mx3oe{TCWg1HnVy6PpcGPm(E^G|(jv@+Y*7N^D3nblMt)NLolVTmW zy_JrvB`OS%i7%@1Wzsx{#6 z;)!01TYu`Q64R~O`4!Ub%+zHeq|$4U6_RHG#6yAk1qw2?u?ga}91)e2J)9iShXah7 z1cY~ffVXn$)Z)uNg4`Bo3lx2JaZhPZQ*X^^DXEp&k6JZ2wkH4B7WwiWQABDmUqEj3 z38siR`8#jr?|A+zm@QDMItj-pt>rbYELJ|I7|-yi`wCOM{rX>hk!SlE2I4;G6H#%GHeJ&QVa3lUsg|yHkWe;Jp9b%ky4a zj;!v6*vpEqM#B>aA3m8Nk%@7Aa+$^K4*Uf%%x*>*Z(1LJugg(o z>^Z?^V)cx~PrA2%u7^9ydHT(tC|8HtLr zQ&|DI>_!_UE7po4lJ9wfLOub$@QHrIwIAztrl1&jZH2kQc%90KY>T4?6MPZn(!8oPM1adm?ygro0GM*^}9*6ix%a8gf}oY zmV+1JG*Nx!|G*8DxB~T(jnY$IPyoLBc&!7BqBVWWUOUk{PJw3@!2R*NK5I?W9etRH zl;;KV^pBnT2|(UA!Oy{I9{e|JAO%su_1I6Qb>VP#P-l4Wb0BymdE$Q16P^4hk0y>< zH198xzvBeHiG0{}cfVftnw*Tg(>JeF8Ui}k|5R+wA=!=q&isdT z#66@uEEst9f!TKj52Q($$yYQ>DF8$1(Mr#mpDBt?E{EF#{2Myd-;Oj=5T%(ZKq4(b z+pE)a0{x9$<~3z!autB7h628({?*PXdjae>f41d30D2a19$wzUz@VT~Dh#L~Bb8um z8E~yWcx%^G{603aHr+UnbX1)gzS!lNerjOY8^9+;!0PiTjEbI$60uVr-?$t&=s*NN z=A;kDfn5F9dS662aXWC>psQ|h!BJ8i;F;9b)wi7pnHjK6DFD`Pf8;7Vhf-`!-Urdu zYf4Q`ZDN4H#^QbdwJ8+TdGlFM++o88eUm}cAnNngpr9a5Ov#@O0ltraFWG7$=SFN~KJwhT<|5$H$&LJF{Q3$r9VI`WUl!%GLYrLazo(w@;}i$d z0;{?T&{s{32GtD-%>snfbB5dr=5psFh z_TM^m8F7)$l7H$*PDu5S$2C`v`iAJSuLRIgE_=9ICM*{yqy1#YB3 z*#XM9V(mwl1_uO^H}g1UV~fE||2*hCaikqJ!df{60o%R(^|;3E$gKH}v)2XVCT8h_ zik5SCyOlBap-RnOItviwMgn+QSfx zJMRr5=^Av1Xe_NBFx)7r@Yf`#@{;N&uTIuqhy{X4@?A5{Qfs`+O_?MOmc|(O(eBsyAJH&*N=*sEB1`>yX^sMh3CaQ|gxYidwd#@~|`%9JAU=;bv4$SH)5(o|1d zhAoZ1e6ltnml<-zpP8a1=($+45$Z_|<;&k)Gl^qwO3Q(63g5CH^$W~QlF|-cy(%m@g<%edz${B zL^@=5z{Y(M=D~nDcPY>NFi1=}QhCY7(GM;}o<&-4p z#bE0RuV3fyl8cv4F`IY^A#xg@hODG_e7{qGqnqp)y0__CVBu0n3`nt%+_(wENC>`l z>-zQU@84WHqC4TyrqIe3wiO|&qxLKjc+J-DlnwO{-Sa(TkP-FS1jMkDa@ut*Ik_hk zmRmRd+{Au2D6#}PU-x|Lh3N)Hksa`XhgUZH%C!h1OgFxJj9e-BN(K_M7G|(BLxb!C zg)-jY#B71CetmEZ{eoeFoFLb#i`*|ykP*ghcLM<;!#FR@wE84Rj5IX{^xMUz;sgka zp8@UtI&h^?X8X^lXMiSsd4fz(YP|w;iRtM!Szr^w%y zGC+6~@+RTY+l2V|c!oQKOs&N%x}6(>bhia<8Y1e$Iqk)6Qvmg>TY# zTEX|3bl4R61H#~a z+qC03VII|yLMfNEZK^+52hn0O>Pe)HOU5X4tb7}z9iuJs2j~ki?J=(t2+8sekMX{5 zaoReS-VU9&pc{g}z-=;be$f6#w5d$f1Q2dAot#1yJVR}BKO|TiX6RNyr+*wFSLGPd~4N7hdFiW`L8q5 zqvSn%UWa|YD5Ux&K@y1+*2%T@PX0%@UP6OoY!#rr4kyry8UMKP8-m}zw5c&v2<(;X zo9xOWjiV=@T?n~36Vcon7C|ErtR6D$6d&Whe@{&(L1Av@)AQ%g@2#u=HpJx6=^iI< z$*9c%f0nm0_FEf@Lf)#vm9SzpK>P$)FY3hx9tCWm!0U~FW1>ggEB2k_KM=gKP?TEBqQKiOwZqUK+SB577 zzAdhL+g>v$bI`ST&j6B*X%7Ss2FA&j1H)qav%&DYBtU^~y$$j9UNeSQabSQArrk50 zj<0R&W#ld=rnsKeMjfQUmJDJ)6xEgQ^7v&p@_XCAP)5*0AjbqS=h<<>vqSl6I-lCk zQ71kFa*y-vur5XDJs!VzuOElX+o^B3f|`J`c^df)lO@iZv+RTsva$MjZF59&7ZW)Y{0%IUx@Et`EP7E?pUai2!8u;@2Ocy7y}bV=}R| zCLvl|Bk(jLXa4SRtR^e}(LtZ)jEoE-gdqknLp>N_xLFiMPXM#P%kZI$i?0QkKxc=w zsU^4$5BoMLo{-{M(5BiAR#1ckfKEY||6vMlLlZf1`CtAi#fY06p~sfShR|tF#4LxI z+!8_L=>CggO~tg+!iOfSWhnLWvIxsO9Lw06+;9X?3cHnuVc&S52EKFV4E9&kYj5>+ zBxXbbra{5}CxL`VU8#5ou0a||0rl=#Mj0zFZMl-5cM9@l#c7Y;qh0&7Ezu4cU4BM) zRS`K7t$)Op^Y?$@imySO?kmQ%Y&nCv%REpS+c!jGh}ol3f&S&+40=QnMC!disMgsc z9D6%nhSjVE@YnxujDz8^nSOq8aol!&LnqK#N)}c_Of2pIc%wN%PAd5M{g6`uSKQxC zYTNOD_|gAEaRne}dXk?;x19fBytp3Vp?3{-04ak2Rdy(kOu`0BLQ?uVrv|)B_UnS{807;fO3z! zQ4|XO1Cs%kKQEd%&!|of0I!Dx4Z$o&;n^q0V1S@<=-Yta{O9_=R&iVV%cDMbtbXqx z0!K*RrbxggQht$ABawW4k@j%U_)(%CQKq zL3uhhHVT%eFZ|2x5Wy4HYOf#iV1N#5p!+lchl(5iON9MDAzZeH-jGacD3hoK=~Bld zk*5wvT+LI8`i_2JXH^dcLNL&3v<~|FkTc4@70QYJNZ}e|V`FgW5=_eHy5-?!DYk+$ z76tgt(Zi>zCk+Z69Q2k^N*x>9q2xL@w@mELsDT0Z;CBj*j6x!`28J0C?@oicgOY_z zQji2soEx+p{69A8EZ8VI52wSS05I7fqFkGW!O{uZ8#ds@$cG>QH~S?ZDS{{k6PhvT zM)4j%T-16IIn=;(`TtH2&8_*TWF{BmoO)wL^JytA4YbH}dUP+M%x!FV7w6}%(LyB) z<8##|jOwiLIs_jRfg+OP?!ZRb4y6)tHfu1E2jR@!xTr@=Svu6oLKjt;4n$9;ic+Ga z{Z1KA6!P66&jbSUXk();hb~1X7(a0L6XbojElSOIN7}AaFKo+*JSIzLNTOiqjO0*R45DB%hg{IjfruAu&fk+WR(ZRfHpc z&uyF7?w;*Ydt}Nb5#spuF%n59Z|9%~Qh=TGla~}&$iBvFW~PzUE4z`G2heJSD(sapxaOXcs!`u1l2NnflF2mc~IbvC9F`|ELAtcvl3@ zkS_o*hMegBH`_a95T8~_hJ|rPx)Ks;(M{pbH~;TsOv#u<{K@u8zrxCftp7UcDX6sH zx2RG`x$NG<4aQO7mn8h-zdS|z$&##no5y5t{TkFfr!SE8(eSoJ;-}vr-;nI_hgws9 z&avgamBpKFLz$70OtgoMAU|h|XPXK$=5TNP!B4|L1)w3B1x!|h=Y5BEM_VvM`;%wE1NIT=aK0hFxNp`p{g(t|?tSqscj#3FJd0iU2`}He6Z2h{H zIY-H5)&E)91ai|PMQip@y$AGccH*$L)Lh z`fQqCDhXMCo2^KD`^JsQc|(!E-wpto;oq`@co9prJf#|H64rblfFO0AsW6EV*!DW; z>bc$>+f$;IVDPpkki+8?t;g2$a#o#yd-v8jsbjg5H#awBpz9z-5cDjE*u<uy0Ea58%aiwJ_+`0c#zy#m`rXVrRf%ooA;gLz2mA zw@SdO`M?yA1cP`yL=cj_Jw0-#`IxdK5H)~fHtP{ze9n;^OqdB{xXHSj2x)6ZVLu!H zud*j))t8o*j$&Rz&#OyL9}3Uh{~0UgzniOoQ?0uK7$!tCxsv|w`%Wn1>VcpZrTQWD zQl7VXQ*@!XPKt3}#Hcz#Ai-V&kwxX< z<>Vv=CfYq*Yb!uHq03cOfA-*iRaIegAB&c@=E}JyFir8FKAV^PQ)Ins9ow!R&w6e@ z0XG=g9*EkDjT~jpHbx2nXGb2BOT!gpJ< zvS8hTciVYhnXpz*E5tBKiXJ=@(L9BQ@lj27v;b>6g|%61_(FLUTcor(`FK9x*Z%(S zt0lHo{@{q%pM0VmDYB~a`hKg;GaifvP?-+QLAwi7qdL#a>E8?R2mN|+A>P85(o5O9 zdtV;*z^C)3n(n6kh1dfNf7O7-unZ>q>TJ#=3c(g@q%JsJLYozH}U+uH6Qg`N)x{TSHe+@0p+LJUfsQRctDZXgBimL3qAvU z;n|LBFCaSsH$Axt@&N~ZxDcY>ob4Gvg}Em^NrV?v?icitNZ~Z!7VkrcU>$E`3RHj9 z+jc>p{nf?a&)Y~pqw9KsZK{tRrnYPq$ zus^Nj2@d?t1W#nCIkd*QQd~k47X|ErF&$**6c`Ll&kWjncXfgjA$(57iw^&k6mAHz zk40c2bHneVG=a^{1-%#o#ZxWcC9G*{TrQJ=yn%h+>Dm56Dj>P2v~f}Ynn_hhWxyuu zUYO3k0_Tx*UXK*vEvdc*toIrm&|$P1*g__B?2+*!bwPf#jjexQH)hAK>Cc{ofKQ$sd@k14YI1) zsWfFVv_eYoBm8DWyM1Zx=e64B@KiUdHzLLcmbaBWRuC*)kGc|ssaek(VEH-S(hYTBZmZKo+ zgaNQ{YyfLk$(8Obn!$} z{IIHG-Ctg2QJ-Iao8G|C=NoSDWqV0KwWC5j;o$iqT1F1sw_;VO5_1&|`WuYSEbSCi z>NbleL{dZ=>ISx@xvhFhenIoEla@I3d-)sL96BTDE~dkpFu?5ju&h$UFwJfz*-fZ+is}*K>|}@5>rNr=i(;ha2tsxf1c%gxW`|9MAG+)WU7iD@FjPP`~N3 zc?ombGd`Sr+?A#xm})3u4T9qm%~3E;1=khh^_+iu0g$2?@IhpxTi~YmBju-_?%;&+ zZBTMKVHQ`fj^lg?h?d(Q9@5Z>utb%`$(P<%NYR*yH$YYc9Pi7fp9fwpF0i`N};CnbWyedu?F&`3IYrcIUDIV_>Ja%BDXxS*(w26+1;x zIC*dA-RqEv5VGq-mE4UOL->j&i5=~lNDNr?Y(pUGeD2@BCnX_qH#*0;?LWUXi~Fl2 zL4yfCZ=;?O%3o)oAAJ=ZomReKGYXXXj|Fq&0FFNk5;gL~AXBz#_V2sEI_*!B4Nh#y zyAHn(7#N0+9gD~IcX6gmG$l#pcW^{Eqy=soh3+MPOC+12_HzP!B5 zC?Fu9j^lC}a|8lY9bsGNag zm%tE}IW}ib9PJAHIK3 z&$?TD9s9}A1-f|gqPBDK2BsfaYT!VmU@gK6($-rnN9y}FKbN*?y4#mqOnvmBE;yZ~ zpZn_7t25C#KCQ`vGnDx5xKk#Z^!#}VwOy>f|pS=c?Vd*(7$t&-HLl4jWjn9t{+!~L^FgV+H1X!i0faLB+ z?;*NO{`~p#j>gC}G@0i8__aUl-ufDrNCc)oksB|?19ci-T}YIn`i#jsqIcrKX`!33 zfNR&hnCy){R5>C)-e|l#0u=9{59Ga?Soy5d!a|KP>mVwO{10Vlg1nF;Ud{7uVyzbS z@9s`F-oy3yA=-*X?2kS>2SV?8y z=qFLUE0b8w^|tPqS;VB|bkehD{3jmYq=cIGl0V3JIcK~pVa=r&?`MOapm|Rn128cO z94Z%s(OIDzo?d)?l|%I^cI@i4Yu9)lPu0pDC(`K2%@OJ%V@n(r)U=K_gYaXRiNBqb zELf!Gzl2AJI_G?(mEv~j!ndZL%9JPTpp63^$MHHEic4It{XvQiRgvd{C>taq^Jr;p zcZ?KD)}I{RS|ggcfHI>`-t#;V1_zf@POl@bya&U>dlxQ5g&ONeTY&QzqUtr9JCeb|A1jlvR7?FiaLC%(jt>t9vg_*WxA+V{)PGe8`lCf)rlmu%>nBHriCB%ymChSQx2=Q;_eFB1 zGK6M~!Mhx5O$L5EliLd1>{wRpvAd1ZL7+I8ycwu(whnR-j8cSBF5l7e$dmsuLlb2R z?)H5A_fI!7d#e>ktMEb;^)dD&wHxYoaRx0g{*~(u<9Qu6c|J8F&wu&*)TLqI%5Xbk znAgYS!y%zSX>0nib!GQP$`|32$Atcq;Ve;NWkW?> zMxXY%*E5NDkEy0+a2PWJb0BRRixAEMNiMy_17S(T$ww*t%42NTHDNm+4 zVdRd>z8%m$8r;O?9j2TXBH+y2?D0tcM^NMC$ueH?BHj$2D#Gf-U_E^eY%l4 z=WvyKIseR$qO?*qgYXw%QN3vS0%)z?-fB6mccL~3ObNU(KLxiGpPoy<$x zno3hUa(pgDLrd4z@|pvdKTPuMWj>XuClTUv=AI%EZ_j`Ukm!=XW77`TauqDTfp(YL z|LAY|<#p#HXQCw^NH=Q|7j^GoW;7nSHu_G=Pa0>RP_wgtYYDT2)nLr&dx(+TN&$~m z2694l$R`zkh$LPB(&jbKwv&jEOCl_{Gl^aA2FgG3cOd(~arlN0pZJ>n8=r&2hn4UVsk793wh56oK&(bzIMMhscni&AH` zg_w+gnXw|0%jOm&k4pq_a4&%W-{ng^seVWK125+zMexBei+tQ1Np;DMEblO0x8tcRD!MKF~6=n0lAV^c0`+@3_BQ0v;G*FXr`?z9i4( z2g)dpv?aU4ZbMdb9zu^_#-7O;rO&A#<5Ed50gZ}d(x(ZaGH{^rS#`w&_rY^L2$8{Bimxivm=eKo4IBqil&fucul zIJH)%GWsQ*5cV2>`ku$=%GAKXKIgKLEyAB|xxz}Ahc^>e|B$!9go+63aEQw{1dVy8 zUWfX(&@z(iF|il~bggtbCmfz)s+=3I_VHW1J5w=U&2R0ddn%pD84e|JIJdVON6Yrb>W0Yjcy%@p?Rt5<;?Fz!N@ z?Jh!j)SOiAtsz?F)92mX>1b2yyhS}=9!jPUPkU|V*=E_S4f9iVc5G0~g_jh3)p;dn z{({s|6Xw6PIa6u2%lQCBoxZ~~DV5Ey(zGW(sa55$^M!qf>|syLyhD`)iA~pMrg;&{ zp4a$Y#|(yWyBYsedFGw`gNLhGK~ zULK1RcgI5^LuD0}tm97riE)}#$&8GBH_Gy2CQe=h^yYJ(ZHgtQ-X%@$ukidIe7$!d z)qndxe(aJxvO-akJu)&IRv{7DE3=N7-LWeqBMmbYl|mHZ$j*+OB>UKM5{~WQ7{BXy z-}m=>-=E*__c?#P-&yDNIy^c1T{NMTJB%X^W9o~mG_#p17^>PwmiID?xi`bmkq)YoZOiUU+~#H zAgTp(6KcK%_(~+_d2yKI+nQ4ruh+BJ?^Bi2%X@|@hnJQA5zT%`=SbXGIE5CqbAgsa zqR%QO?libpDPFK^8X9^UO7n3#L|bN0-^V3?A1FTF(3Z*^Wlx1){Bsz#?B#Th!gJs3 zJUOdRh1UdncoEJ$h<81oM`qhLVoO~;G_|=`U+n$RN7>^pf#{QM`+($W7?u;WsAc8{|3zNyt@HLEH8PPTV$rccB^l@J*{I>|IV{yeYs z+%wznAvQE@x9{%U3L@~gj}*1U*9%2F+CI04u*x~?CA&l^(Utw1k4R(vNxgdtdl~(x ztazgDoo$S$MV~o#o*dgRZ%eLVREJ1W+?VRdkDRB+N4Aev4oKop&&;BW7fy}~S$(yl z*f|lfV~t+ysTahsv$M~oLuOdKG;S)YO0(s)xMlhMp11mzG)$BcTA7-$dY3O>MzU$n z#Yu}?HE~U*h(=v`mg>voVUeMC4Wuf+AydZ>J)17`$+|(xe_mQ>`$;p7gd5FP zCJ^c~ye>~0`o^brVMeIydfU$J zm^1RX#^1SDb?xWs+?Fa^Ng66XhWA zFt;5#GeKdgV21R>IG1MJVdv0ni37d1|9BC4iYciUWDuWU68;E(5^og0d%K3=R2M52 zaw_C0GNuwP#fDFWG^$Mf(j2p}EMHskp|(`0uA=4{93?+{q4;a`Z*;e&S8hw)+X{X3 z?Vf<~zV0kC>^-<@^P=wyz6LLpcUAjmQqZbt7z|QDJYd*Vy2bsxxJS@;!H{G8hu7D# zZfDh>n%AD{BM-39BRpa)@M>SZTv?t-2+XRi9Jcg+xazelT9bFLVnQN3m@9x;U@Xt4 zBCN&Tvae?jZ8&?{+qOsdk6L_nPuR~YDS!F?#rJ4R)Jk~!DtLJaw2e#1z9HV0)Pgu^ z)91;_lf=;C@}Ybv=8j@gj6VoNwR>)xHIhgGcU(>h)I2`@i%Fi|2_@l?w21 zS=nLo@Li|2y17e%b@juwtzm=<35>74i=vOvR1gApPNOF+d%SZ$*|sbDixru1qHq1I zn#v003zG<_Qjq9o^dXF;p>|MfwmpBiux#^$@mj`^Q<%Cr99BGtK;ZlN?1)3B5cPgU z*d1ZaDQLo%FKcvv`?0Fl!IWoh;XsZ3c|}9$h3RbFZNF?G{q)Z@=RYCDa`r>A2rco# zeUq`FstK05N37Xjze4J}+bVe>eZ~@WeWQJfn%UQsq!z8b=H4$hoLWqoQ7b1ydbMw3 zB6ulO7PIcAj_OMJPyV%bZ;qcVdb4AFJncug#2^G0{7cvKhm;F)#`-Atwmj2 zC)Fj>6|1x=M*N)0V{PyDRp#Aei=LOS?8QASA=~$ouq=0@u^tTW1_j%DaNb7u4FNXS zDY<=nin!;7T)>4_a5)r~ZR~*wwkM#DX#Jr#EgYI+mYzI=?89JV|1lJ6<&^{$5_=7`1Ji4mzIspllQhq53`19k!n}>1)VKfqZ|4-rE^;QC0Bv zDtkS|MSDHS-)R0IxOY+_spb@i=ZPnOkh3Cc<;piEp5W5z_Z#BVQRpOBFXV#&ZRN&c zW*37x#;vHc&A}gU4@2%o{uR2>e5s=nR_GK+MMEq?pqz!RJK#iDsrcktj43!BzJXpz z({QaH;-?z5rLE4eK>Pp3p0n#nqn8a6W!1Wmq`-rxdO~^8_KFw_ls)#79%Z!qpcnl> z!^Yjvw$!E|ZLtBgk8$La9LRxk#*OAK#w#CvXzoZeG*-cZ?EE;y5&ovYZgA8$o*QSd zj;|CqGRPEMkW8$v%;al~kK&Ih5ZSeUx%&0jNv!MEhkGgkR(;(jzll#Phh@DjZYH*N{fxVIV_%e9h@)egXy}q;gM@eSRC??_4hB=%74lkg{+;Y=h`7k zoxE2R07qq|CCe{YYCJI^$LOjV18w1Oh>}gy(^oh6)EYb{36iXmJ{$MA!6T+Yc=wPp zaZynsx@?2Vq0{fZasDbzqOZ~jAnk)KsjCnsl>l&Un5c2JQ80+b1AYda3t>J(PJ&0s zYP7XSn9B^tj$n^`4BE1MTk}Ohc~r(FgcyFh{r>0Rt(8_UK_`LxNn4IzO9O7s1_(t) z)N##aj;*DgbKfoFI>qPl=%m-f+b$FD)hFNnO&-?@?O*rVQ}27~$tm-r`!>P^1Nfz8^T+nmCGRJ(CR7-Pm zaYL+#fxbkn!wo#foEQPpZZuhmoAvU-PnFmzVQU z+0^xxJ{8O#Pb@BX9bqPRD<_IlIZvx?yjrq3nPNH7cg=KC>jiPRr%HBXmw2wWO38)2 zj{lD+|9ZIRM6DVx`ld^jdwmiP;NW{+rZ+>uz&_V*Su+*AVHWd*upWLe9HT zgL|_EfCY=wH9lfIH~o0{-to4+-d_68qcfD@aJ;s{P_(4t3d=Yh5*9+z5AZU&W@zor z$Cc{?^6zCE-?y23+@?{C1=>*IW~W!I+QR!cYoqzMZLKCz$E=a|3R4@0y8_rHW|a^M zlSFo_i)hvgy|n`Lg{DLA-XcZMcs18{wSHLLW%uIs*j{I_lKwas!Rq54@Hh^dkIvv8vR*)WFwMVbi?88K5+d7 zWqq8OI2V@-4xx2IO2i9!g`^2(-ieAG2`lB0e5*L8nqw_@#2l4!}db zYohlU5NaH6I{a41rDCp1#@)EP9^YtH`_Usc|ixCM;?wM=1w)rAzX-v;l;~a_+JzkgRsL)M&_LHBeE21{Xu{a8o z!98}5p&etptN1CC4V9qL2UX)sg5$>Hk17*`&9M)XYBvJ-l20rwb82?mnI?+iX?3Ji zX{#Y?0%g74CVEuP%tVFD<-cL3$~0C1qmy?mnflC-;4q5oQ+vcl^5?R~NrO!y8(g;) z&Af?vfr&rmtScmyy&n!GG9r}!Mgsc^9pQ6Yc#sD$=ih7{j1y?v^WSxxc2U5)Gn zB^CwMKvoHJD@{Vu)Yan2w;s0lMbYa=v4__DvD~A|UY3{FI~#1iy3_jwNzCy2+I;rn zpf;)`GOl;yR((UhXDv)^;@im8DQ<`Fw}-5`h%IOIP8Ya7vI@}EgFfMwV%5P2BkkQ z7q;3>Jr*0MbtP+l4gLDH)^hg~Y@sW&&;`&odYJ-SwzkRCbTL+`k2A^h8ceL+{@7L)vO$X&PJAuFZ(3-w*;*@ z;=>6WYRT#KR;+fIn8*D(obdj6zS+}R!3NV6Tv9==& z1EBf*a1=dH?bXqtSU}g4r05vO0>(lzywuqc^T6URLaPg5qxYu8vmn>_2LRQOtH&|B zEJWY9M2lFLE(sAcFM0g|bjk#K&Mev&@;7Xwx3BR}p%c&b4RL@J!zjo)uDSn}+OJmh zd@e+Iyago+kN5sk;$T0s1Ai%G3}ySl8NvXk8VbC+YCEUw>$H~wnty!9Ij#0g3Q(KhQg)qzRbzF>2!jEH;Vqe6PsqwAL$)F&F;Mx z&N%4|qFS$9X&)ZY(`saYQT!Iow~h`P?oY`ADLN+_#3f6kgD zFcoAo@aq>FA^DPnIh$s89|@7lWYo)2*^+YTl;3_YdeZ21LX$pon5>7=S@c)?;%4?A zuG~M*Ch1C4I$A(NBCSGVus?o6>|>WjMwg>Z0cW#9D7fWQK9u$IIH)CEc~hGb24d8V z@aFm;*thf(9r`D}aduwL>(O5Ws)86VeL>{;UvoB+&O^gdW2?4KJmWiG72wP>z>YQH z)xNyFeNXh=hWwXBQ&kW8Tj@F;`5PwnCYeZ8kWIv{TuGCD+ip=cU{S@S@VzC{(lgSs zv#tjEQx5MIVQA?ALZ^1m5e@QaG5Maw^iY;gI;g0i0F_s^K|79wbR_SWP7pYNaw;9v zj^K~7-}Kx+$4Om4a^wsd@I3>MipC^Hh|?+Od6 zO?t~UV>=*Iivi+gTzDL8pcxA}`i?DWbF)@mIX34y1V8ivUywnfz6PwwvG+R!_ajA9 zM7>eiM4g3%JmFV*q_ zfdxFLj?dGTCHfy$vEu;o1X>Vspi8hsAFTs2tZ(Q&pr5fhf5u5HqhepwFzsBT-p3{` z>dRR^!_mP!0}zJ@0{j|j?vK#*xQL2~Y$&t@lPTT?@ujVZ@5fA#IIJ&d2uOpFAKTl% z45W~1=GE+}pwZztX`c^e{LpekI>erUred!ZttT{B3w=XEz*3S>gG5|Vu^BQ$1!Jik zh-Bt+2O~VshcW;t6AoaTF2KH{~D!@&MVY|u4=k729UR*a~!$PBv{a95}>5@{I| z)3%8t?v;ZFES7Y_ZK;io-u@Q>2H53?ZB1}0QagVc-*aLiR8U}TJGV}shPE;K~9^TflLHji`;?7BfxP)&P%oW~=7x<&HqvWs8J z)Yo&YITWZlJRXVbFsFF|Kk%%iq~tQf@U=8|(x;mrMXg&1yR8wIa)gz9K$J9hSAHpE zUuJx`CDjSI(2_`vbFrT>tD9_;7fQgLRYG%)PU_PhC!DcXLAU<;iV!uEhT$Q_cAURHhzo05Yvi%@b7Kk}6tQroO7OXaEJ& zB`)ZvMHRgwXQ1-Z4Lc;P-df-f=ie?2SEL|Z$S5x?ooAxFlBF3N^DkcYS7gCtrFK3Z zE!g1DEpA7x`+{tgJ*~eEL5UhFZVP0OvVR~wBQ}2Ke0yn(p3XfFljm37gnGoC;|U~J z9I>!GV)byC;jeh#P#F};5@0_#Xpa@Nc?_30>AJ?5yTqC2HJQKOeD>_wXKshSpe({4 z9hI@yb^5!A)C#((XC1r0E}gokz?zl{x3#0PF4v%y_fd?F6X}NwZCBSoas_g6XpKM9(V>P_g`Xw;TMLl#SjVy%9z~rx_)b$3ljrz~ zvCt#oiR7)E4kYn*9_&h$(n97I7TcL`bW`vmZttM#TynDI#p5NZZN#rhk%|xlAoIA5 zS466%qOR7$GRfZ_22^Taph%Z;NZRZ)fS>0xyO>duDn!3MPgM)q)(Z!Fgv%sJRFI(_ zw)c8vWhGXM4$RYcd-&8}Ni*Jj&)dRv;>|+X$W*9i%X?TM@12~SXztq&K*N-ssLaQl zq)2BWMYky-;k}n2JtI7xmr3)aecA**je7GBA3pd|#d`nZa`*-(O4wc;KYQ<@ul*M{ z`z#y9%%usD{&zW}Rtw8G5}H<>bmtSpUoDQf&1V+Wtxcq8=XfS93n%GxcGYN)@dSuX zH9*N)+3#mdlD=7gG6&3#$L$!rP*5a%K_pHa=x~}qx+(_MwI7TVeHSpIuCH^OIH$;> z1G5xJRqO)O$;pJv8&h-{ zsf|xovQG>hNne;qme|bO8u*D+I+YiRwZ-CRHCtlHw6lC3p3K70`)j&!zf`CNp7uEu zA0EyQF3!-yzP`NDl02JNpXnV7m^1AnhPaU$@U~QGvxbk_;Y?`G&C9m*u<}L2ed44U z6TRHv!9mT>jAO^h>I%NhCajz(PR7h1|CGBsz>87%p2ph3OG^BRlAXe3M-qzwft^7;lAm8w zvs(gCt^$|C43~q_qe#E`p|UwS2ffSq)!#rKZG3%jrsRJ#-xruP?qv!JbO`-Mr==sxI=HV%0pje2RBk`5zv z+IPl?i}xChV;x^;aD5WrI0Y{kDRVFqmbja*b%R||AW(Kqwj+yjx0Wx6ZPso zxY)qEaL=1YK+xsCBv49MCDvl%c>V|dd+rIQ=7bzlOU7P}VkUT8>SbenBlAXiLcjiu zeu{bx@+6U!D-j9~uV(id@DCzIo^R`8m*e~(izBRXwRVxXo$a_Y9Il%Mr#2n+1gcOf zz2SHtm)~6*F zS?o$4Jf(NOHS4%na>j3ZK572Cqe{uY)mb#K`?PWTl6#%>^1()|O+2m79;lfnT&ln1 z8~-g4HKLUjfX4>KO27TZSqk0j^Wxw9vMn#3RuOx4T2mx#_n`9dgiq1(W#Mx??{K<7kzeFDWEsHF&7 zN>(h@V@zEkvP*vBJ6K#;M`l3Vp;j~BFQ+hBI9|68R0?I|^s6{bHsy=Mj>?dEkeenh0usQp5p=zothY@glh3C&d3C_kKQh17gH%-9NIa$Np+3h zc;ZO~hqvJSG4j39sp<}I!9pG{q%YA&-b-nTWhomtMb3&B>u0gP^LgRQ5yP`6<%+rR z%k>7~#8tk!qrw!)ldr|qeN?hCQo}ZJVf)8}h0G@DRJF3; z2(mW-f$EHQp`f)?dfHxSi}sqZ2Xi|ao@RkYwMzjcOk;Nli(0RB{!3^m7)oWVv2otd zZ~Yfot*ap@p0;LNj>=?FO9Y6w? z{@&hQHU-|vMY#0gT>jd&9|t1HilV8)99NgDC$(elrlVrTc zn81`FXB0cSF86d3@1v#;?k>*J!!N40624tr*v)9xe~ve&+mJinHloh@u2Z=@KfATz zw-$fLi0z<3wt5a~5<7eJrBA^y6$RBu^jMFoH{O@Vx>&sK=Ps9T^WM2HEV!%6Ub&4j zU+-GWU3p`43%TG_4<>PSvfnMKEj1fM1+}I60B&G8OXVvwU^m>$RVUaaY=;R zS>?u!U-EToM!S#V6d;muh|VoRnc)nrIC|3blDwSd-j#@(T&{;3{H@C7DgNwL*wILk zWkqLv$+Xo+dEou&moBPfh)swPe;cdxSW8cAsh3$8b^6w4(E!VIf*J1J>UoY*f$_`Z zyqDrGM7_jJ1EuLF^jU5x z%hS2!-^JYOzc;85Ff4B;S~2oG?q%px++i{MxFDa9kX`?9;n+RE<&`HHfC`SnEe*N! zd3@{KyD#T_s)!tE%O`h&!?;gHZC>uDfIwBjfAlUBH=Gm9pOJaCwfi{IU=4x{=#yXK zpH?lLBj2&Kk}fhw=l9w+nT%z{@lfHByWV*b8yB+D1L__Va{~6h|22=O%DYSzXMfRX z1#9X0Aw&RjrW6CObBX>Zx4HDs`XKFV#x^!KfK)>0AK~2Gt$@yVBTM(h(*ze8CrUZH zD4fX`>i0R(yJa;U$#qU$+Z#!L4IHZ>-ZjhO#tr}ToKf!3fz`>qmC+z|Dh{aQV+7RE zDv{f=$gHjJK52rUjZ5tfL)@EF>Nz1lspxQRWC0*K@fc-I$pl!MNC=m&(Y2Rm~}MIFA}UaEJ9#8SfXY!wlC94&DuQhGi5 zieojXqzLVw%+X)XUPY{Sdc94@gA~{yCaW?@4pO!nLqS|6ZeB z!8l~5p_N(Yp8{;-YW3l&x&q&GZe7XcT)hUE1~29)nzmt)Z#VhMlMU)P@jgR^LoWL^ zU%4RV|k0y+vmo!u)CfUZ{5`CcKjZzsnhOU=T8h{P++0^==K;la6Js6 z6p*(mG?Mq|-Z0JfTk=+^6Y*6^I6$<0Z*WHK-gsW{?j2gzlulphF@#BE#x1!f$HcvG z>PW5$AI%le6jk`X`RM}BxBK>VN3&`v&9 zADl0(xW9~cU|~*LUif&z@tGI!www(mOsTjV$2yu9$$a1I*9eeHT9tM$KPUPPwt zowG}RUp&2gZ&7&-GG#fO+=(bUGwn$cIxw}V;B~#ifa^`5(Ea696@JgS22P)I*2J8e z6KQ%3@bqgq>ZJ!Pq%%hBawi4px{N$-3+$}&|DM}26jpOiaWPLi8qiXipZ*A!iSo?t zLmu=?K4`gyF^BQ5w&Ue@ztB{uZF_8w4Odd2r33aQ#yRQ*#vQHH))hV2s*1~65enm4 z;rqX)mQPi-@^c?=d4moq+aGBClueF zsXRW{{m8|C;tpspm7dYCgOmUZZW2J4Ywz)K=I(e$(YUjuXIaY*N%&nAx-N$cae8(M zB81L-W~%U9%^v~QQBgHuzl!4X9HREe)F%vMZg%nd>ZaT!MMA;7V_`wzI8V;6t2knX zeL1GWk+F+cw#8({%GNf_j!lz>LOnqlM68cEBqcoE-D_w8S-;p@?u1Q6Eu>dc*Qx~S z`m8ti7llmDAiK_d6RCuNwC7p4-v2+YNplOO;i%Br@F8V1oTr(c>j(NuR-;sKl{EFZ zB>ZSA%s-^X(=V%o=Bn=6D=B6!gQFox_rZ;$9)H46t$48=Z4)oBJV|L2xgW)}X{>vU zFV-vn5iuS-Z`16Rv=>(}4FS_&TtN6hq)Jxxxi~mJ&H)P|q4&nfp!w*_Cg=7ir`#c; zQ-S<-&#m1%&%Es|b$z26jOljiETz+Gx)7n}?^69u0VrDCUZ3-P0jJO(MU*jZ?}kVY zo_bdFnGykq!7E?NpOFVXnK1B7K78Bi6b1z2N{hfgrGIzkzbf=pHbNA@-;aHJ!FX(C z>j+pya;-1g#-9Jz={in$iZ_whxoB3i)$o41kH?t@q~(|Y{{0z^MZ+_E`-m*Etg(2X z>{p^ep@$Uwi0jO;x-FI7&s8WYERb+y64QNSB>9^U#l7hXcm_>%UUhXa+0w%1MK)$G zF1~VKbmQlw-q1vNSZ6{c2%nUpdQUhTx*dBT?s${awB1K3)8?LN$LP~${no(5vJGGA zt691q$~b@z<^@>athsEb#__T=c$3HAv_NSr~f z@D-nJ32s`gPU$5PJbxVmh%cvlO)ulWd!4iy3nsa-*_+pte*N=B0YZZ!F)WzwBbwY^ zpiw?)v@ipBsC&D4X_O2VefW39#rt_X6ozcP)boMh!K&uN>B+Usb7&ggsyKZ`=(MKc z=WOY>)vZ(Q!m%5Va^B^-;96355x-j7HaJ3b&jDlPASE@n#UIQR3 zeK^1b92?z^T6q7C^B4z66VUAb3+-73;HkTU`)1I99}R~w2?3U?us7T_1vG9DSzOci zWIqsvA}Wo84Pekc-tY3|_Ep&8ZXw-^ZL0^}-ieb3z3Gz3?Y4NuM0Bdc)L;(~mFJj$*MYtmt2ytM3+x#R%fW zURrhW=g(`A5upD_`Xrpfh9NqB+@Qv2aBz2Kd}!vzsMzcK;>1m}31(Pnl0qQPZ%QPn z>r~4Tcx-M2W(DwFBXfhPfE$l5F>FkJ6PSwl-%MXAf*1i+_ra1=FXY{al){f6I{R15$Pvt67P-O}z<;QMJMnb|=|lnN zeWmecl7;8tqbDwDOeD`?MAc-%C5`Pqki|uksumK`l` zN|w__v+6+aAg~OZAYh;DhclwOvBSX5IKELZXD)zSE%MDV3ZW}fi$ijW_iF6dO}nh) zrRDL8+C4s^&NZ!Oi`xu2J#;M;e~!myS%yw~HrS|^Iydfmw<@9M;9DW^K1MA4) zd4+4r$oW?1pI_KFv41pxw!PHg!H>M%OCqs(-Q0L zmhd*SPwvCz+To|er4F37In(AsBn5Ig+TpP(E3-AD9?uoaN0m2iJ_^++DH7VrquF_Q zUL;{1%f;-+n<}4@)!N^a#mhI;43bC7yB(O9V%grqFJJ=4sAFW$XLn{U)|t>L-1)IoBvA!e=g9dA@r-38n%ZgS750`IhQr*uvs~(VFcd><+@V2BUz=-x|FiYl2m! zbL<%`pvQVbs+d)0IGE3?Ipl~BGbe1&r!WZ#E-ODp zDgz401!MRjO~cob_5w2Yw@6DFiLg#s353s zqlmZOG4a`f66rfr7qwU`8YM#S%=v)AmfU&o+7J&qsO6NwSq{a*ktbL4Y_%5+lX7|i zQ>7m`dSDv;2^pDjTm^M^@V6bl6QX~7mMiH#ji>Jt`y!sEW%29~heMQKGY{*|wF;O;9TwoFo;+wibgHt<9 z>D_9m=ln}$U3omfyY-VYkbg9aqOmzgfrr*fI^6gXtZ+w{*zygI3$Q*r_%#4IUCoep z=M86ZNtz_#P28H@N)DZK2X1Q6ex&H?>h_aKwj2=5qzCE;co!M4><7R%P?kpzs^tNu z!}eQk8O|q~@TZsyXz{}03aA>!oB)UKdz`D0(mRCjrrEoQ7FSAZ5?kZ=3|ecQq;%8* zMop?+FNkj5Ldw*^?9hf1^zdI*d zSKe{*0o_eoz3&_3GqLTyp_0t7eWC@pm)CS&kcl1R;p!uux7nrdb3FPx?ot}pzBkA@ z(@kLeU0Nf&-BUe|C&c-?d8hGXD;K3$UBU;c4#PYkc#XcC4tnP1`7qh;9P+UIyII5ttMhWs|@$^+LfN4R{GQzq;}IgCQy~@i?EoXf-WO*_Ai#^OuKpE<9eogJ4#TRnSnq zV$u}(gIrvnLcob-=&Zi;M(C)zOv70)TcBiCiJ@x2>G<9Gvd}8$bLQqmmPaPs4iM`L z$5-1UkhRDA4)jN7nJaZnDnMmZMardPqbyRvMdZJb8FGm8)C%b|7KrW68k08Z!Z2h$ zlcH*&?f8J$Q~SE2zMyvipgw+0RQdytSS zmI>`{GEkDb5yeUlQ+~L8-rEulOU3hpuUe{3`pv$vQM<#e{}zn@eWY&^dU~0ZNl6W3 zGf)DMo&d=<$)pHh!)vi2kvEv)(p~(X^$R~T8x}fq^;O`}`tIC!`&Fogb5nQsfk*v& z470oi)|1iVqUz;W6phal7xpWG$$NS)S+SYc7 z2l@Vz!c`4N1DUiP8wgwcbH3bNawTM6tfRyqBytCHVAv?tq{IyHX#A5A`?Ap!A_N5I zJoO)cMD|V#J+8RZ=X3p8W!!#WO!f7MF-DtL!@=X#%0+eK8B+_QY_wbsofjQCzb=<+ zYOrET3SB*dB}h|*=wIi{#z`N61Qn5kq@#&%K71bnU^r?$yKW|p=e1m1W6G4qYu21F z`A`C5dgi0y*!{=_3OU=b2G(mK!zK!9YgcV|37l;z@8&m}_x%P9wReBTXD6k_ghI3b z1w8%N>*p9DeVY7cT#$(g2nO+_2*vYoCPgV8y9&}t1=8O&KJGRgdX_ISoAsYLCnBNc z?iDbw*_br4A*!|G-@^`~8rmUTmGtVC3dG1hr)>4U2&ZyS8brSzfAct_d+wRn&DQ7v z*%?8^Rhnt0`mr;y{I&BbVT8ENnZuQ)St}s?aMluLQ!>%mIL-2~m9&az;9#fxm9X1< zu+}X9y|AudcJ=gRq%b45gGqlZzI@!uexs~IqrN+)Dh^qcUaH|o$U-EK_ln%XSQUhH zBuwX2P-Z^WYUPw=t!IH0>4Sky(?K>=ch$5FjvOos#h|xOU|h}Q!!~E;!Ffdn)66_! zleUC!))|y$^!401^OP|=cZg9_V=pjnXVoUW(3dpiAu5@LG*&@4<2$}9B*EjK-xN3~ z|NOqONH6_(#7mzaoAX$&uO{R*!IW>J>sv<>PmQh^RNqH|K+IL=p2M?ucJ46I;B+`? zCXWEEQTNp>I1`I}o$z|FNF3A?TI~ms$nFIfft+Q-^)_o>Tp`IwkMMZw=;6Lx_}os%V)@`WhZv)gH9$bOg%loX@oiCSrzLM%3QAIpvO z`PT=fAD)x0(hBp%$#$$vIuOCuCj8PZ&kFvEAWQ@N{7lF>+fQX1I|5cwc+O|$7{x*R zK$RJ-g*h*(9aj1!P5rQ;D+|eD1QMKrB^AlJFL+3zJ&{8J4@YN=RxY55bH3Ju=7aGS zuio)-I>%L#)zcwFt@=M02t6eTu^g_bsv^20;1e^4*^Yt(&)Dum`2w||E&ynM6|WkG zjHS>%sPLrIUdY@$d6o;ZW{<(J!u-F@r0CfQu?~x8Jh?8Ud{SZIX8DJTH1&I+D*d$B zg5B*RAj0!&Rb%Yf3VoG6eks=beb&ApL{pEz3n2aBm|oJOqHs_V}AB= zzW@8%L!6DaS6B?&Me;k!#XFRG;C%4j_}g5afd<2MlXoJEK@t}#ZC?h9|2cNne^t_b z7TfK+6MzWzy&vru|9ea|EzNbZ(6R!53Q8e+A)JBo5Gw4jYI2UV_fDS+kemxAnwu6` z1-Z&+>>ffuE(6SF5X?C|(LgMunj=S)Mi;QRnc^f-9!S2Mq=jU7Sh&2SoW|=|t7GY) z5MmW^_B6}kJt_UOn&NS)b(elwQI7ZC>wW)cWYscZ&o}GeKl8WU2ULISlaD0j$l6ws_@3MNf)5|8$q_)T*8yBSQZwxEX~0s$ zF*#qY8w>#zqYID)WS08fnIl%`(cG7?h0>54kS6g+`t7}t>Ab|=0@D;o9l{opvL6*- zwV%$L4EmUurB<|ic~}x)L=)x34~45X8U8=B_v9DFF^g%vmA{`0hC;^vnnKgt7Wn3{ zHAv#=DifQlsa;f0(i5ta=L%u#sAGq)_X}%eFRe8suJwLscU&oYf0ysU08MPL^rLsF zY`^VDa(^-AAkKOkT}!3J zcz5E|yVy$T)9n}%d}n(%-}ZFOtA zl|Ko)1PC8S6hgwFp}okL=Qv1#eT@s+rx@2qq$j9t|6xy&O7$8rU!r#c1bh96tB9p@{eJ2S zL-Mef7;C%$pTyKd10B*vzs3mL2^^WO%exKyPzsh~rh5NQViU_uYn5H9pN@?GfmtxPj*^>2+791 zYE2E}xLD^EEIe?Q2pnv7wAY2%WLi=mG@7y)GKqD>ayuN&zkPS}w!k+9lT7IlyYP2Z72VaNz8O&nz#t4ZOO`W(R!>B=2Z%*4CMs^t3xZseqwLmnXl; zKEDrKfK>P?M6zOn;6eT7a&RU$gT!E%LkCq>1ygVygZp#qAn1|SH0%9IxU#@f7tAOf zOliR0%D#_y_%We=;Pn7t)?awHvtjD z7b>jmshK<+wT8!$TGzM@n-#Lh0^PP=N0YuRAmUx^mT~1G6i+!A!|H%|`Rdg~<;&G$ zad&4d;)31yJgR@tB5YqY>1aGH0@T3*^vw@&LFWB_wxj_;yzfZ;%USNsxgeXoxi65C zOq!%<1&sx?lU&Oxp6_8}<83`Nu!u5=A?Ju&`PkjZ%KqY-@Y&YY>Noj!4+ei7?7eMGP&XFl{wvz=>P5DkY73Y`tD8y=chDG! zL{+Ns_y3F&62)jxIqtm?&qS2R&u~&@rNVSH((74cyR6~F){JYc)3f!1e>r>i;8qsm z!ZgE~)!fZO%j~wwJqcY#mwg@wI`31qv%X)S58F^I^}xN;e~bOVcKuEq%X3Kb`VDJ0 z=E^a69RIl++|;N4JtC`d+-caD1soQ+Fufp!jD%fgKG^x}o@4YG{0x=JPMN0#P#_K_ z95lZr?x>_iqKkQQnP`%Z3Tf^c1ktbPojP%FX7~z!w|o5Gg$SMwQWMi9)grbQlFdjb znDeB$U6!hd)N+?PvIlQ*a2`86ZeqAIbp2#v!N|t&;o00bZ>p-RRj8`>?BLly-jZr+ zBIgu0yMJ3=K!n6h{pTs*!o+kMd0Fo4CQ@ZwNcbWXLRIqpxr-4`1#!>rq>d z(yfS_qxp-yez8LDyrV!mWzig-qE*|{TP~Ss;_W4zSCo2gox4MXzD$x2;xCQ&le)k${B3TAcMP2;F0?NuSCuX*_NG-_HwnhY~n{GbdTMW}ZbB zj=((4K!Fl-4SD5+MiZADa#n_DWerDAAxIunQJ_2VSlplTe@b48`*kVGTfzy)nwdwt zG5oy@JAQg25Z>m2V2qo!6G-<3sP5K56A6Q1@suA)VP6^;owj5vy0!qSA0wPjvOV`5!&Whh5dzkog$7R*UZRBj$ z-hVgs@p<9`>46ZE*aO|Shzh3TOA+zn!G=M)kC1|Dg;`ay?hlcMRDOv0hIiq-Xy2p8 z(9GNTY`63HwtXerXyA5!VPPE1{`dv8EMaPinDwq6rp}xL+o4JCL3l9*JjTKbS{R0d z^A>vLSa>GkM)GXdt^HP0F{W-0lc33gfpT@omLD7SnoagVn7Vr^O^jkuFUIJPlh<>M z2QXdk%>Lxp6L`7{0hTqnV+?t%!wfLS8EmEB9c6AI77p&TaoLgcL!6}tXV(i8L=WO8 zccLM)H<;!UPk&ixW$`?WDH~F!AHR)=ULW3l9bu!YzA?{u`pek+i@d4H-xQvimUo84 zGt$70kz-^x>`zMEb83vD|3Lcf_olx2WVzKWY`Qjm4&i@%>e90plb87581S`@pLKY< ztU5}RX|kTCyqf!;!?HlmUf`lj)_ukX?zYFQI2-C8#cl=?le-5WoQ4J!3FH_U{QM`7 zY@RupM|x)FGX1~4l>4=#e6>D0_)xgqB!w{so23HM9%OcC=!((v#rY{Q2^&l%ZW(dHZ^WKo@gt2ZrcSAP9toSw`8P&q7>~gazDdO(zBZO5 zRuGvCkwI#v`j?^%E`xiwy|Opap={A^sx71CPAVa!)oy4X3jx0{=7NhfV#71{WV!(9 zhp+eM!SQ2JD8Io0S-xwp-Lp&}+Z@;VtNAv|s-fuhOXs6*} zrXxyD-nW5XmXMS*AS+f+jftU+k)AOz(dTj?MP_SI{J*QKOEt&V*F!J<3h{V+ z-liOdw`D_?f5#Ny6gDB|S0(%Z`H)&ttqPK?LS3-UU@bUhRdSxIu+Q1q6fDWJ45@N> z3BG@WMF<NMs$CT(Vc!)J+n0w##3=zi{K-a9~d2VI+m2J`?oztu!hZwWmyh|_$|gp z;ya61|99fyUjd822Oyv|M*i{x;Xe`#;)yY;uy>RS3ku$ShaA6os}LR(#PwgW#lJmj zv@3cucKz1hSXc}5<2({UqKhq(yHvo9Xc~;x{!Lz2jAi7DU@vE{q-quPH$k(z>(}Ld z$=`4h6}I6TA|1(laGgA_!6pRw-JMxK?AyZ{ z0cT9&B3>F9_@%L?tw9kqCTOFZE~#E58*2%WU%kVw-uEMr6p+!(EI5&T3R-fq7lQfL z#o@SftfXYwf#ils9MI!kD1K?c&sC{izh7FD0)Xntp%S{2w3tYRKwn=sb9hPamSYu* z5@z&wxa=ZWz`YO^WVGRf(lKM5+S6bN-%P}W2_YMX2nN3rPhV5Tamcs@f8+E-McwQ5 zEqp<%_UnJV*?gfR4Hr6L*{i$5t6yKnh2WcT5l`+XdFBp=8px;`G8X$G9`1fw*4W@@ z=!cuX)OIewB`064zZkel2j~oKO4Q10Q5<1BwG2(_d6eqs(s;o|cAPRU;L^<6 z_B;=)kQzf*lClVF9aujq_);1S-o#|9m;=2kCe>7LJ6dO8|Id{VIzE;hripcG@5Ak4 zGJLTT81Z(Rp50^na+F5C?!&&}lk_w0&=k2Pp!vDw_Ug#@r&F9L6y!vS${d!bB`Qxc@}mrbx6Rg1t1Ghv~7a6#?ra_2h1Gup%}Ff1?_L-as#tro>p+Q z>CU^WS5221E622SqHYk5Y11I)G6~ZRT4q;#33kHr!eAlXJC?Y>g|AW_aO+ z$4^OHpzVNu`7ph{rR7WCUedw)Eg&*fOsZ49SA z-W8ZPbUasMkLGYX`o?dRxnu9)Hg`zd-qxmx`9=e)fQheHT1tMi7db-8Up92^Lc}J_ zIg=@AR`^2Y%=DHGu|G?_A?!bWa3>z?Hu{uw*8#w9&Gq%PnC`wCD(nMu&k35hO73uDTMAXTKH3okhj?Z zr_~FN)Y)I1ISLt`DM+>lf|H(z3PJ%k*Ob!W3Fd~*@1263Qan)h7A-_y=$sS@pT&^! zA)r|)z1c+>&pzxH3V(aqXfb7h6In+wPh)a(gtjckX$1}lH zQxh#z_;P%GM#ZX2yP_bXOJcxQ!5dukkbYrNk(H5EK|*3J1Ss`~O!;V4y0?OvqIG!w z4~(ffNZpz-jPHk+FW|;1(p^tY?ts=}=HO5GL>yzv24?OHAjz*BC|lGVR;2Plm$KzH zlp^b1&^G53fct1xpyabUsaT%_I)42A&Ex#i)w`V72<02mh zC$n`z%ZY{*2bJLUoP|IF&i!NmjJUz{I9n|shDbq>ISPKS(Qt9zEOXR=fjmeGIWqS2 z+Z_sh+V9_0P)BflD`vQI!&0XNJE%-A-kF8#WynW{w_SX%%mMc|l21IY_Z<~|*fsMT zBu%gUimk=3%Mwv7UnA zY_nqtRW~A*fQRjqs@(4BQ6zeB=ajIgBqC79S53RTD*aS)n0Rz@+2{EbO@J2#dEI)m zn$Bdqw$E8gEk5ooyj;2$TT!E3tc75#cw@_S=luY;{lf>^Gv%T8?pw@8E|Hg?o)fu*kS}Md~!RFxbq+y-rp&d#N*JWYguhf(WJp&Sum&=8~|ONc{9L+ zs*73UrIXvKhHF6u9Ki?G>x&p+o6v#FveI^GL{GoUBpQn93`FxN@Qh6QbiD;#JY$#; zDxI2()GXfL^Xzjwqt~zH9p5`W={_W0CV7=H*C%2q4J-te&I6Hb%U0$*Rkw-_nbD;l zr@{jC9apn;*+mnBdOzOJ3F$LSCf(B(?Iz-oDx!|~BT#`cvkP5CT2hMnHd+Xyt;q60 zi|@wX`l4TAT6*@QYNE&xw7g&>BYg6%Hw zZPgwY*!2d0rvoV22~f6D@Oh@hq&g&tDKRCr&-S5k z9zwr1^XIb$hNP-=^#x71ngv?E9MIa`6FFX2kJa534co51ndWhr!$HloEWSUfbF*hGU0HM zt(f)4Tt2f>9f9H8;UTR9@#qnSej$WNV;EB!oT!+wAwdwd2*;CufkV!g$9q^@9Lmyj zOydUB5y?#2tNv zj>8ksD|-}=Ue39V<>5h07{fS+$0>4@-t2%vjgD_PGSd~kM?Dxy=5Ll;cc z3;tlUi!2khA&*DkeW5mwVoy?Gb)W_p&6H|KM&olhnN!0CngkmT*aP;CGSGNDNAw-~ zgF0ddBM4@dI};M!34BfcW3X)K)V4-=3C zboSMm_!H(+9WI8?n_VcngwjF-Xj{J49(D2c?ebPG1WSqspjKt9ks5Km_l8dj+3qnf zbBkSOT4BEl@+vVJhzF#_USbHOiG}3BofY^GE2&@`kWs!lu;rdV^;HUVJpO;YR-RSV z<#4%Y{Ul&l7aCs(T0IwK1Ie8kp*tXFexo;vtrQICL0`>Gk6?oG zPoGo+=`0mZ(mdr4+9)WWN@=}TiY@n%d|pM0ZGCVjf)uHTXyW;wuI@Ig2_(`qU!t9$ zVZprf+ocf3+nP_lGMTlCypFXQSpWAek3)O!gDdvz)kGDqAsr$)h8007n*nN3d9XDO zqiEu_`fty5(tVfL8FJN#qq}Xe2wol`no(K^wb-c%SyA$aVW`C3(hqq?F@{7|o#Fa- zmKFpx<&MF!V}1rq;`3$CV<63+mClr~Ro1OqeE!vv7Y2>|L9s&qrYa+5U|?*CR0yEs zI@crJ&LF#vDbK}^ZK}HC+E_#~Gj$ct7HL5_Q4pl_6~s59e$tW)k_u<+n7x69x5{-s zb4FDZg4D?MvwYYa7SjcAcS}UZw%u%vgwq`ozi;bWRa8kzza*KYag57(zANkB6 z-!!zk83mN4@w0@CXkF#Qxp!| z#2xYeFg$v8G%sl)nx^OY$s*pDG^y`f=ZHO!J5d@1!8a*4zuXdR5Ot!qL zXovXpj2GoGxcQv}*`N{1d}uwppl>jJVeT?8YVxYV-UL+ zckhp4N~XW#lw;ky&=|6YCJ=9iu~zDi&x4YP&Rh1G=Eom?j}u7F2c?86&3p4?}~ z=y9BF^PYrtNW1%$PXxL(^`fg(>HsKq^~V?syrATK7ml539I^{{xd5uWd!+!3ZUS>x z&T^m!#Un&7aK66`A zZPNGHrQBC4WL@iz5swU(N`>wikBlg8O*02-AE?!=p^`@uxjnB2|LNh4I4t>R)=H?_ zLr<((2(UXjl&;^2jkT2OAD!K7(jtTo_Bmy&1?Es{pKgkH>a;^wcJS!YLWT5B|Iq>< zNjv9H=>Y5-OX0r;DXX7IoK`g560yFs5WrEW*^)Sc)bjIP=uWvQBnW^Pa1sT1fiiGH z%{XcT$|kOfKL{z_G~CBj0D#Sy?U{r#_bwfxc;#$upb_P#;mv4lVxQ_ViyK-$AXLA6 zb*@MXeA}A&4L<=%UZ+iFutM%l!C@c!oIhy9*%n`WE}IcBn7J8T-xj1)OK;=)eh3k^+NShWyE`vE7fv&gl+TnKAV*Tn8${yZUIS*Y1}bCk0#kJhH$lZlwG&bg`{CD>{&NFw?J&GFa=hr* zEBC>*PG@4s9XuXy;Qigx(c*wp=E+^>>;!n+3dk$}h`7f66!%%Mp@y(o!A?O*h~h*6 z@tQIB%VC8$5A3?>3q<;;f+E^MqN%+pxzDEubyoZdfa|hCBpZ%)0dx*{6I?XR+- zFu_CEQOh~rB(sI0c&JAm^i5J(x|UjG^{y?f!xajB7NmC7H*~!1I=-1~hB0P*J1e4G zKh>V7uRvbnOlS?t#W$kQq(?T`(7aS*6yVx;4hU@Wwi2R(wt+Lpdn+t)Cjvvj_~1S_ zx5uwTuD-|kgTVXTym>edT;AW$wB-xGRkTyXJU5$qWD>0<&|jm3mo + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/pybind11_vs_boost_python2.png b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/pybind11_vs_boost_python2.png new file mode 100644 index 0000000000000000000000000000000000000000..9f17272c50663957d6ae6d8e23fdd5a15757e71f GIT binary patch literal 41121 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 BtT6xp literal 0 HcmV?d00001 diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/pybind11_vs_boost_python2.svg b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/pybind11_vs_boost_python2.svg new file mode 100644 index 000000000..5ed6530ca --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/pybind11_vs_boost_python2.svg @@ -0,0 +1,427 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/reference.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/reference.rst new file mode 100644 index 000000000..e64a03519 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/reference.rst @@ -0,0 +1,130 @@ +.. _reference: + +.. warning:: + + Please be advised that the reference documentation discussing pybind11 + internals is currently incomplete. Please refer to the previous sections + and the pybind11 header files for the nitty gritty details. + +Reference +######### + +.. _macros: + +Macros +====== + +.. doxygendefine:: PYBIND11_MODULE + +.. _core_types: + +Convenience classes for arbitrary Python types +============================================== + +Common member functions +----------------------- + +.. doxygenclass:: object_api + :members: + +Without reference counting +-------------------------- + +.. doxygenclass:: handle + :members: + +With reference counting +----------------------- + +.. doxygenclass:: object + :members: + +.. doxygenfunction:: reinterpret_borrow + +.. doxygenfunction:: reinterpret_steal + +Convenience classes for specific Python types +============================================= + +.. doxygenclass:: module_ + :members: + +.. doxygengroup:: pytypes + :members: + +Convenience functions converting to Python types +================================================ + +.. doxygenfunction:: make_tuple(Args&&...) + +.. doxygenfunction:: make_iterator(Iterator, Sentinel, Extra &&...) +.. doxygenfunction:: make_iterator(Type &, Extra&&...) + +.. doxygenfunction:: make_key_iterator(Iterator, Sentinel, Extra &&...) +.. doxygenfunction:: make_key_iterator(Type &, Extra&&...) + +.. doxygenfunction:: make_value_iterator(Iterator, Sentinel, Extra &&...) +.. doxygenfunction:: make_value_iterator(Type &, Extra&&...) + +.. _extras: + +Passing extra arguments to ``def`` or ``class_`` +================================================ + +.. doxygengroup:: annotations + :members: + +Embedding the interpreter +========================= + +.. doxygendefine:: PYBIND11_EMBEDDED_MODULE + +.. doxygenfunction:: initialize_interpreter + +.. doxygenfunction:: finalize_interpreter + +.. doxygenclass:: scoped_interpreter + +Redirecting C++ streams +======================= + +.. doxygenclass:: scoped_ostream_redirect + +.. doxygenclass:: scoped_estream_redirect + +.. doxygenfunction:: add_ostream_redirect + +Python built-in functions +========================= + +.. doxygengroup:: python_builtins + :members: + +Inheritance +=========== + +See :doc:`/classes` and :doc:`/advanced/classes` for more detail. + +.. doxygendefine:: PYBIND11_OVERRIDE + +.. doxygendefine:: PYBIND11_OVERRIDE_PURE + +.. doxygendefine:: PYBIND11_OVERRIDE_NAME + +.. doxygendefine:: PYBIND11_OVERRIDE_PURE_NAME + +.. doxygenfunction:: get_override + +Exceptions +========== + +.. doxygenclass:: error_already_set + :members: + +.. doxygenclass:: builtin_exception + :members: + +Literals +======== + +.. doxygennamespace:: literals diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/release.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/release.rst new file mode 100644 index 000000000..4d390a07c --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/release.rst @@ -0,0 +1,102 @@ +On version numbers +^^^^^^^^^^^^^^^^^^ + +The two version numbers (C++ and Python) must match when combined (checked when +you build the PyPI package), and must be a valid `PEP 440 +`_ version when combined. + +For example: + +.. code-block:: C++ + + #define PYBIND11_VERSION_MAJOR X + #define PYBIND11_VERSION_MINOR Y + #define PYBIND11_VERSION_PATCH Z.dev1 + +For beta, ``PYBIND11_VERSION_PATCH`` should be ``Z.b1``. RC's can be ``Z.rc1``. +Always include the dot (even though PEP 440 allows it to be dropped). For a +final release, this must be a simple integer. There is also a HEX version of +the version just below. + + +To release a new version of pybind11: +^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ + +If you don't have nox, you should either use ``pipx run nox`` instead, or use +``pipx install nox`` or ``brew install nox`` (Unix). + +- Update the version number + - Update ``PYBIND11_VERSION_MAJOR`` etc. in + ``include/pybind11/detail/common.h``. PATCH should be a simple integer. + - Update the version HEX just below, as well. + - Update ``pybind11/_version.py`` (match above) + - Run ``nox -s tests_packaging`` to ensure this was done correctly. + - Ensure that all the information in ``setup.cfg`` is up-to-date, like + supported Python versions. + - Add release date in ``docs/changelog.rst`` and integrate the output of + ``nox -s make_changelog``. + - Note that the ``make_changelog`` command inspects + `needs changelog `_. + - Manually clear the ``needs changelog`` labels using the GitHub web + interface (very easy: start by clicking the link above). + - ``git add`` and ``git commit``, ``git push``. **Ensure CI passes**. (If it + fails due to a known flake issue, either ignore or restart CI.) +- Add a release branch if this is a new MINOR version, or update the existing release branch if it is a patch version + - New branch: ``git checkout -b vX.Y``, ``git push -u origin vX.Y`` + - Update branch: ``git checkout vX.Y``, ``git merge ``, ``git push`` +- Update tags (optional; if you skip this, the GitHub release makes a + non-annotated tag for you) + - ``git tag -a vX.Y.Z -m 'vX.Y.Z release'``. + - ``git push --tags``. +- Update stable + - ``git checkout stable`` + - ``git merge -X theirs vX.Y.Z`` + - ``git diff vX.Y.Z`` + - Carefully review and reconcile any diffs. There should be none. + - ``git push`` +- Make a GitHub release (this shows up in the UI, sends new release + notifications to users watching releases, and also uploads PyPI packages). + (Note: if you do not use an existing tag, this creates a new lightweight tag + for you, so you could skip the above step.) + - GUI method: Under `releases `_ + click "Draft a new release" on the far right, fill in the tag name + (if you didn't tag above, it will be made here), fill in a release name + like "Version X.Y.Z", and copy-and-paste the markdown-formatted (!) changelog + into the description (usually ``cat docs/changelog.rst | pandoc -f rst -t gfm``). + Check "pre-release" if this is a beta/RC. + - CLI method: with ``gh`` installed, run ``gh release create vX.Y.Z -t "Version X.Y.Z"`` + If this is a pre-release, add ``-p``. + +- Get back to work + - Make sure you are on master, not somewhere else: ``git checkout master`` + - Update version macros in ``include/pybind11/detail/common.h`` (set PATCH to + ``0.dev1`` and increment MINOR). + - Update ``pybind11/_version.py`` to match + - Run ``nox -s tests_packaging`` to ensure this was done correctly. + - If the release was a new MINOR version, add a new `IN DEVELOPMENT` + section in ``docs/changelog.rst``. + - ``git add``, ``git commit``, ``git push`` + +If a version branch is updated, remember to set PATCH to ``1.dev1``. + +If you'd like to bump homebrew, run: + +.. code-block:: console + + brew bump-formula-pr --url https://github.com/pybind/pybind11/archive/vX.Y.Z.tar.gz + +Conda-forge should automatically make a PR in a few hours, and automatically +merge it if there are no issues. + + +Manual packaging +^^^^^^^^^^^^^^^^ + +If you need to manually upload releases, you can download the releases from the job artifacts and upload them with twine. You can also make the files locally (not recommended in general, as your local directory is more likely to be "dirty" and SDists love picking up random unrelated/hidden files); this is the procedure: + +.. code-block:: bash + + nox -s build + twine upload dist/* + +This makes SDists and wheels, and the final line uploads them. diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/requirements.txt b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/requirements.txt new file mode 100644 index 000000000..d2a9ae164 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/requirements.txt @@ -0,0 +1,6 @@ +breathe==4.34.0 +furo==2022.6.21 +sphinx==5.0.2 +sphinx-copybutton==0.5.0 +sphinxcontrib-moderncmakedomain==3.21.4 +sphinxcontrib-svg2pdfconverter==1.2.0 diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/upgrade.rst b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/upgrade.rst new file mode 100644 index 000000000..b13d21f5e --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/docs/upgrade.rst @@ -0,0 +1,566 @@ +Upgrade guide +############# + +This is a companion guide to the :doc:`changelog`. While the changelog briefly +lists all of the new features, improvements and bug fixes, this upgrade guide +focuses only the subset which directly impacts your experience when upgrading +to a new version. But it goes into more detail. This includes things like +deprecated APIs and their replacements, build system changes, general code +modernization and other useful information. + +.. _upgrade-guide-2.11: + +v2.11 +===== + +* The minimum version of CMake is now 3.5. A future version will likely move to + requiring something like CMake 3.15. Note that CMake 3.27 is removing the + long-deprecated support for ``FindPythonInterp`` if you set 3.27 as the + minimum or maximum supported version. To prepare for that future, CMake 3.15+ + using ``FindPython`` or setting ``PYBIND11_FINDPYTHON`` is highly recommended, + otherwise pybind11 will automatically switch to using ``FindPython`` if + ``FindPythonInterp`` is not available. + + +.. _upgrade-guide-2.9: + +v2.9 +==== + +* Any usage of the recently added ``py::make_simple_namespace`` should be + converted to using ``py::module_::import("types").attr("SimpleNamespace")`` + instead. + +* The use of ``_`` in custom type casters can now be replaced with the more + readable ``const_name`` instead. The old ``_`` shortcut has been retained + unless it is being used as a macro (like for gettext). + + +.. _upgrade-guide-2.7: + +v2.7 +==== + +*Before* v2.7, ``py::str`` can hold ``PyUnicodeObject`` or ``PyBytesObject``, +and ``py::isinstance()`` is ``true`` for both ``py::str`` and +``py::bytes``. Starting with v2.7, ``py::str`` exclusively holds +``PyUnicodeObject`` (`#2409 `_), +and ``py::isinstance()`` is ``true`` only for ``py::str``. To help in +the transition of user code, the ``PYBIND11_STR_LEGACY_PERMISSIVE`` macro +is provided as an escape hatch to go back to the legacy behavior. This macro +will be removed in future releases. Two types of required fixes are expected +to be common: + +* Accidental use of ``py::str`` instead of ``py::bytes``, masked by the legacy + behavior. These are probably very easy to fix, by changing from + ``py::str`` to ``py::bytes``. + +* Reliance on py::isinstance(obj) being ``true`` for + ``py::bytes``. This is likely to be easy to fix in most cases by adding + ``|| py::isinstance(obj)``, but a fix may be more involved, e.g. if + ``py::isinstance`` appears in a template. Such situations will require + careful review and custom fixes. + + +.. _upgrade-guide-2.6: + +v2.6 +==== + +Usage of the ``PYBIND11_OVERLOAD*`` macros and ``get_overload`` function should +be replaced by ``PYBIND11_OVERRIDE*`` and ``get_override``. In the future, the +old macros may be deprecated and removed. + +``py::module`` has been renamed ``py::module_``, but a backward compatible +typedef has been included. This change was to avoid a language change in C++20 +that requires unqualified ``module`` not be placed at the start of a logical +line. Qualified usage is unaffected and the typedef will remain unless the +C++ language rules change again. + +The public constructors of ``py::module_`` have been deprecated. Use +``PYBIND11_MODULE`` or ``module_::create_extension_module`` instead. + +An error is now thrown when ``__init__`` is forgotten on subclasses. This was +incorrect before, but was not checked. Add a call to ``__init__`` if it is +missing. + +A ``py::type_error`` is now thrown when casting to a subclass (like +``py::bytes`` from ``py::object``) if the conversion is not valid. Make a valid +conversion instead. + +The undocumented ``h.get_type()`` method has been deprecated and replaced by +``py::type::of(h)``. + +Enums now have a ``__str__`` method pre-defined; if you want to override it, +the simplest fix is to add the new ``py::prepend()`` tag when defining +``"__str__"``. + +If ``__eq__`` defined but not ``__hash__``, ``__hash__`` is now set to +``None``, as in normal CPython. You should add ``__hash__`` if you intended the +class to be hashable, possibly using the new ``py::hash`` shortcut. + +The constructors for ``py::array`` now always take signed integers for size, +for consistency. This may lead to compiler warnings on some systems. Cast to +``py::ssize_t`` instead of ``std::size_t``. + +The ``tools/clang`` submodule and ``tools/mkdoc.py`` have been moved to a +standalone package, `pybind11-mkdoc`_. If you were using those tools, please +use them via a pip install from the new location. + +The ``pybind11`` package on PyPI no longer fills the wheel "headers" slot - if +you were using the headers from this slot, they are available by requesting the +``global`` extra, that is, ``pip install "pybind11[global]"``. (Most users will +be unaffected, as the ``pybind11/include`` location is reported by ``python -m +pybind11 --includes`` and ``pybind11.get_include()`` is still correct and has +not changed since 2.5). + +.. _pybind11-mkdoc: https://github.com/pybind/pybind11-mkdoc + +CMake support: +-------------- + +The minimum required version of CMake is now 3.4. Several details of the CMake +support have been deprecated; warnings will be shown if you need to change +something. The changes are: + +* ``PYBIND11_CPP_STANDARD=`` is deprecated, please use + ``CMAKE_CXX_STANDARD=`` instead, or any other valid CMake CXX or CUDA + standard selection method, like ``target_compile_features``. + +* If you do not request a standard, pybind11 targets will compile with the + compiler default, but not less than C++11, instead of forcing C++14 always. + If you depend on the old behavior, please use ``set(CMAKE_CXX_STANDARD 14 CACHE STRING "")`` + instead. + +* Direct ``pybind11::module`` usage should always be accompanied by at least + ``set(CMAKE_CXX_VISIBILITY_PRESET hidden)`` or similar - it used to try to + manually force this compiler flag (but not correctly on all compilers or with + CUDA). + +* ``pybind11_add_module``'s ``SYSTEM`` argument is deprecated and does nothing; + linking now behaves like other imported libraries consistently in both + config and submodule mode, and behaves like a ``SYSTEM`` library by + default. + +* If ``PYTHON_EXECUTABLE`` is not set, virtual environments (``venv``, + ``virtualenv``, and ``conda``) are prioritized over the standard search + (similar to the new FindPython mode). + +In addition, the following changes may be of interest: + +* ``CMAKE_INTERPROCEDURAL_OPTIMIZATION`` will be respected by + ``pybind11_add_module`` if set instead of linking to ``pybind11::lto`` or + ``pybind11::thin_lto``. + +* Using ``find_package(Python COMPONENTS Interpreter Development)`` before + pybind11 will cause pybind11 to use the new Python mechanisms instead of its + own custom search, based on a patched version of classic ``FindPythonInterp`` + / ``FindPythonLibs``. In the future, this may become the default. A recent + (3.15+ or 3.18.2+) version of CMake is recommended. + + + +v2.5 +==== + +The Python package now includes the headers as data in the package itself, as +well as in the "headers" wheel slot. ``pybind11 --includes`` and +``pybind11.get_include()`` report the new location, which is always correct +regardless of how pybind11 was installed, making the old ``user=`` argument +meaningless. If you are not using the function to get the location already, you +are encouraged to switch to the package location. + + +v2.2 +==== + +Deprecation of the ``PYBIND11_PLUGIN`` macro +-------------------------------------------- + +``PYBIND11_MODULE`` is now the preferred way to create module entry points. +The old macro emits a compile-time deprecation warning. + +.. code-block:: cpp + + // old + PYBIND11_PLUGIN(example) { + py::module m("example", "documentation string"); + + m.def("add", [](int a, int b) { return a + b; }); + + return m.ptr(); + } + + // new + PYBIND11_MODULE(example, m) { + m.doc() = "documentation string"; // optional + + m.def("add", [](int a, int b) { return a + b; }); + } + + +New API for defining custom constructors and pickling functions +--------------------------------------------------------------- + +The old placement-new custom constructors have been deprecated. The new approach +uses ``py::init()`` and factory functions to greatly improve type safety. + +Placement-new can be called accidentally with an incompatible type (without any +compiler errors or warnings), or it can initialize the same object multiple times +if not careful with the Python-side ``__init__`` calls. The new-style custom +constructors prevent such mistakes. See :ref:`custom_constructors` for details. + +.. code-block:: cpp + + // old -- deprecated (runtime warning shown only in debug mode) + py::class(m, "Foo") + .def("__init__", [](Foo &self, ...) { + new (&self) Foo(...); // uses placement-new + }); + + // new + py::class(m, "Foo") + .def(py::init([](...) { // Note: no `self` argument + return new Foo(...); // return by raw pointer + // or: return std::make_unique(...); // return by holder + // or: return Foo(...); // return by value (move constructor) + })); + +Mirroring the custom constructor changes, ``py::pickle()`` is now the preferred +way to get and set object state. See :ref:`pickling` for details. + +.. code-block:: cpp + + // old -- deprecated (runtime warning shown only in debug mode) + py::class(m, "Foo") + ... + .def("__getstate__", [](const Foo &self) { + return py::make_tuple(self.value1(), self.value2(), ...); + }) + .def("__setstate__", [](Foo &self, py::tuple t) { + new (&self) Foo(t[0].cast(), ...); + }); + + // new + py::class(m, "Foo") + ... + .def(py::pickle( + [](const Foo &self) { // __getstate__ + return py::make_tuple(self.value1(), self.value2(), ...); // unchanged + }, + [](py::tuple t) { // __setstate__, note: no `self` argument + return new Foo(t[0].cast(), ...); + // or: return std::make_unique(...); // return by holder + // or: return Foo(...); // return by value (move constructor) + } + )); + +For both the constructors and pickling, warnings are shown at module +initialization time (on import, not when the functions are called). +They're only visible when compiled in debug mode. Sample warning: + +.. code-block:: none + + pybind11-bound class 'mymodule.Foo' is using an old-style placement-new '__init__' + which has been deprecated. See the upgrade guide in pybind11's docs. + + +Stricter enforcement of hidden symbol visibility for pybind11 modules +--------------------------------------------------------------------- + +pybind11 now tries to actively enforce hidden symbol visibility for modules. +If you're using either one of pybind11's :doc:`CMake or Python build systems +` (the two example repositories) and you haven't been exporting any +symbols, there's nothing to be concerned about. All the changes have been done +transparently in the background. If you were building manually or relied on +specific default visibility, read on. + +Setting default symbol visibility to *hidden* has always been recommended for +pybind11 (see :ref:`faq:symhidden`). On Linux and macOS, hidden symbol +visibility (in conjunction with the ``strip`` utility) yields much smaller +module binaries. `CPython's extension docs`_ also recommend hiding symbols +by default, with the goal of avoiding symbol name clashes between modules. +Starting with v2.2, pybind11 enforces this more strictly: (1) by declaring +all symbols inside the ``pybind11`` namespace as hidden and (2) by including +the ``-fvisibility=hidden`` flag on Linux and macOS (only for extension +modules, not for embedding the interpreter). + +.. _CPython's extension docs: https://docs.python.org/3/extending/extending.html#providing-a-c-api-for-an-extension-module + +The namespace-scope hidden visibility is done automatically in pybind11's +headers and it's generally transparent to users. It ensures that: + +* Modules compiled with different pybind11 versions don't clash with each other. + +* Some new features, like ``py::module_local`` bindings, can work as intended. + +The ``-fvisibility=hidden`` flag applies the same visibility to user bindings +outside of the ``pybind11`` namespace. It's now set automatic by pybind11's +CMake and Python build systems, but this needs to be done manually by users +of other build systems. Adding this flag: + +* Minimizes the chances of symbol conflicts between modules. E.g. if two + unrelated modules were statically linked to different (ABI-incompatible) + versions of the same third-party library, a symbol clash would be likely + (and would end with unpredictable results). + +* Produces smaller binaries on Linux and macOS, as pointed out previously. + +Within pybind11's CMake build system, ``pybind11_add_module`` has always been +setting the ``-fvisibility=hidden`` flag in release mode. From now on, it's +being applied unconditionally, even in debug mode and it can no longer be opted +out of with the ``NO_EXTRAS`` option. The ``pybind11::module`` target now also +adds this flag to its interface. The ``pybind11::embed`` target is unchanged. + +The most significant change here is for the ``pybind11::module`` target. If you +were previously relying on default visibility, i.e. if your Python module was +doubling as a shared library with dependents, you'll need to either export +symbols manually (recommended for cross-platform libraries) or factor out the +shared library (and have the Python module link to it like the other +dependents). As a temporary workaround, you can also restore default visibility +using the CMake code below, but this is not recommended in the long run: + +.. code-block:: cmake + + target_link_libraries(mymodule PRIVATE pybind11::module) + + add_library(restore_default_visibility INTERFACE) + target_compile_options(restore_default_visibility INTERFACE -fvisibility=default) + target_link_libraries(mymodule PRIVATE restore_default_visibility) + + +Local STL container bindings +---------------------------- + +Previous pybind11 versions could only bind types globally -- all pybind11 +modules, even unrelated ones, would have access to the same exported types. +However, this would also result in a conflict if two modules exported the +same C++ type, which is especially problematic for very common types, e.g. +``std::vector``. :ref:`module_local` were added to resolve this (see +that section for a complete usage guide). + +``py::class_`` still defaults to global bindings (because these types are +usually unique across modules), however in order to avoid clashes of opaque +types, ``py::bind_vector`` and ``py::bind_map`` will now bind STL containers +as ``py::module_local`` if their elements are: builtins (``int``, ``float``, +etc.), not bound using ``py::class_``, or bound as ``py::module_local``. For +example, this change allows multiple modules to bind ``std::vector`` +without causing conflicts. See :ref:`stl_bind` for more details. + +When upgrading to this version, if you have multiple modules which depend on +a single global binding of an STL container, note that all modules can still +accept foreign ``py::module_local`` types in the direction of Python-to-C++. +The locality only affects the C++-to-Python direction. If this is needed in +multiple modules, you'll need to either: + +* Add a copy of the same STL binding to all of the modules which need it. + +* Restore the global status of that single binding by marking it + ``py::module_local(false)``. + +The latter is an easy workaround, but in the long run it would be best to +localize all common type bindings in order to avoid conflicts with +third-party modules. + + +Negative strides for Python buffer objects and numpy arrays +----------------------------------------------------------- + +Support for negative strides required changing the integer type from unsigned +to signed in the interfaces of ``py::buffer_info`` and ``py::array``. If you +have compiler warnings enabled, you may notice some new conversion warnings +after upgrading. These can be resolved using ``static_cast``. + + +Deprecation of some ``py::object`` APIs +--------------------------------------- + +To compare ``py::object`` instances by pointer, you should now use +``obj1.is(obj2)`` which is equivalent to ``obj1 is obj2`` in Python. +Previously, pybind11 used ``operator==`` for this (``obj1 == obj2``), but +that could be confusing and is now deprecated (so that it can eventually +be replaced with proper rich object comparison in a future release). + +For classes which inherit from ``py::object``, ``borrowed`` and ``stolen`` +were previously available as protected constructor tags. Now the types +should be used directly instead: ``borrowed_t{}`` and ``stolen_t{}`` +(`#771 `_). + + +Stricter compile-time error checking +------------------------------------ + +Some error checks have been moved from run time to compile time. Notably, +automatic conversion of ``std::shared_ptr`` is not possible when ``T`` is +not directly registered with ``py::class_`` (e.g. ``std::shared_ptr`` +or ``std::shared_ptr>`` are not automatically convertible). +Attempting to bind a function with such arguments now results in a compile-time +error instead of waiting to fail at run time. + +``py::init<...>()`` constructor definitions are also stricter and now prevent +bindings which could cause unexpected behavior: + +.. code-block:: cpp + + struct Example { + Example(int &); + }; + + py::class_(m, "Example") + .def(py::init()); // OK, exact match + // .def(py::init()); // compile-time error, mismatch + +A non-``const`` lvalue reference is not allowed to bind to an rvalue. However, +note that a constructor taking ``const T &`` can still be registered using +``py::init()`` because a ``const`` lvalue reference can bind to an rvalue. + +v2.1 +==== + +Minimum compiler versions are enforced at compile time +------------------------------------------------------ + +The minimums also apply to v2.0 but the check is now explicit and a compile-time +error is raised if the compiler does not meet the requirements: + +* GCC >= 4.8 +* clang >= 3.3 (appleclang >= 5.0) +* MSVC >= 2015u3 +* Intel C++ >= 15.0 + + +The ``py::metaclass`` attribute is not required for static properties +--------------------------------------------------------------------- + +Binding classes with static properties is now possible by default. The +zero-parameter version of ``py::metaclass()`` is deprecated. However, a new +one-parameter ``py::metaclass(python_type)`` version was added for rare +cases when a custom metaclass is needed to override pybind11's default. + +.. code-block:: cpp + + // old -- emits a deprecation warning + py::class_(m, "Foo", py::metaclass()) + .def_property_readonly_static("foo", ...); + + // new -- static properties work without the attribute + py::class_(m, "Foo") + .def_property_readonly_static("foo", ...); + + // new -- advanced feature, override pybind11's default metaclass + py::class_(m, "Bar", py::metaclass(custom_python_type)) + ... + + +v2.0 +==== + +Breaking changes in ``py::class_`` +---------------------------------- + +These changes were necessary to make type definitions in pybind11 +future-proof, to support PyPy via its ``cpyext`` mechanism (`#527 +`_), and to improve efficiency +(`rev. 86d825 `_). + +1. Declarations of types that provide access via the buffer protocol must + now include the ``py::buffer_protocol()`` annotation as an argument to + the ``py::class_`` constructor. + + .. code-block:: cpp + + py::class_("Matrix", py::buffer_protocol()) + .def(py::init<...>()) + .def_buffer(...); + +2. Classes which include static properties (e.g. ``def_readwrite_static()``) + must now include the ``py::metaclass()`` attribute. Note: this requirement + has since been removed in v2.1. If you're upgrading from 1.x, it's + recommended to skip directly to v2.1 or newer. + +3. This version of pybind11 uses a redesigned mechanism for instantiating + trampoline classes that are used to override virtual methods from within + Python. This led to the following user-visible syntax change: + + .. code-block:: cpp + + // old v1.x syntax + py::class_("MyClass") + .alias() + ... + + // new v2.x syntax + py::class_("MyClass") + ... + + Importantly, both the original and the trampoline class are now specified + as arguments to the ``py::class_`` template, and the ``alias<..>()`` call + is gone. The new scheme has zero overhead in cases when Python doesn't + override any functions of the underlying C++ class. + `rev. 86d825 `_. + + The class type must be the first template argument given to ``py::class_`` + while the trampoline can be mixed in arbitrary order with other arguments + (see the following section). + + +Deprecation of the ``py::base()`` attribute +---------------------------------------------- + +``py::base()`` was deprecated in favor of specifying ``T`` as a template +argument to ``py::class_``. This new syntax also supports multiple inheritance. +Note that, while the type being exported must be the first argument in the +``py::class_`` template, the order of the following types (bases, +holder and/or trampoline) is not important. + +.. code-block:: cpp + + // old v1.x + py::class_("Derived", py::base()); + + // new v2.x + py::class_("Derived"); + + // new -- multiple inheritance + py::class_("Derived"); + + // new -- apart from `Derived` the argument order can be arbitrary + py::class_("Derived"); + + +Out-of-the-box support for ``std::shared_ptr`` +---------------------------------------------- + +The relevant type caster is now built in, so it's no longer necessary to +include a declaration of the form: + +.. code-block:: cpp + + PYBIND11_DECLARE_HOLDER_TYPE(T, std::shared_ptr) + +Continuing to do so won't cause an error or even a deprecation warning, +but it's completely redundant. + + +Deprecation of a few ``py::object`` APIs +---------------------------------------- + +All of the old-style calls emit deprecation warnings. + ++---------------------------------------+---------------------------------------------+ +| Old syntax | New syntax | ++=======================================+=============================================+ +| ``obj.call(args...)`` | ``obj(args...)`` | ++---------------------------------------+---------------------------------------------+ +| ``obj.str()`` | ``py::str(obj)`` | ++---------------------------------------+---------------------------------------------+ +| ``auto l = py::list(obj); l.check()`` | ``py::isinstance(obj)`` | ++---------------------------------------+---------------------------------------------+ +| ``py::object(ptr, true)`` | ``py::reinterpret_borrow(ptr)`` | ++---------------------------------------+---------------------------------------------+ +| ``py::object(ptr, false)`` | ``py::reinterpret_steal(ptr)`` | ++---------------------------------------+---------------------------------------------+ +| ``if (obj.attr("foo"))`` | ``if (py::hasattr(obj, "foo"))`` | ++---------------------------------------+---------------------------------------------+ +| ``if (obj["bar"])`` | ``if (obj.contains("bar"))`` | ++---------------------------------------+---------------------------------------------+ diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/attr.h b/lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/attr.h new file mode 100644 index 000000000..1044db94d --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/attr.h @@ -0,0 +1,690 @@ +/* + pybind11/attr.h: Infrastructure for processing custom + type and function attributes + + Copyright (c) 2016 Wenzel Jakob + + All rights reserved. Use of this source code is governed by a + BSD-style license that can be found in the LICENSE file. +*/ + +#pragma once + +#include "detail/common.h" +#include "cast.h" + +#include + +PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) + +/// \addtogroup annotations +/// @{ + +/// Annotation for methods +struct is_method { + handle class_; + explicit is_method(const handle &c) : class_(c) {} +}; + +/// Annotation for setters +struct is_setter {}; + +/// Annotation for operators +struct is_operator {}; + +/// Annotation for classes that cannot be subclassed +struct is_final {}; + +/// Annotation for parent scope +struct scope { + handle value; + explicit scope(const handle &s) : value(s) {} +}; + +/// Annotation for documentation +struct doc { + const char *value; + explicit doc(const char *value) : value(value) {} +}; + +/// Annotation for function names +struct name { + const char *value; + explicit name(const char *value) : value(value) {} +}; + +/// Annotation indicating that a function is an overload associated with a given "sibling" +struct sibling { + handle value; + explicit sibling(const handle &value) : value(value.ptr()) {} +}; + +/// Annotation indicating that a class derives from another given type +template +struct base { + + PYBIND11_DEPRECATED( + "base() was deprecated in favor of specifying 'T' as a template argument to class_") + base() = default; +}; + +/// Keep patient alive while nurse lives +template +struct keep_alive {}; + +/// Annotation indicating that a class is involved in a multiple inheritance relationship +struct multiple_inheritance {}; + +/// Annotation which enables dynamic attributes, i.e. adds `__dict__` to a class +struct dynamic_attr {}; + +/// Annotation which enables the buffer protocol for a type +struct buffer_protocol {}; + +/// Annotation which requests that a special metaclass is created for a type +struct metaclass { + handle value; + + PYBIND11_DEPRECATED("py::metaclass() is no longer required. It's turned on by default now.") + metaclass() = default; + + /// Override pybind11's default metaclass + explicit metaclass(handle value) : value(value) {} +}; + +/// Specifies a custom callback with signature `void (PyHeapTypeObject*)` that +/// may be used to customize the Python type. +/// +/// The callback is invoked immediately before `PyType_Ready`. +/// +/// Note: This is an advanced interface, and uses of it may require changes to +/// work with later versions of pybind11. You may wish to consult the +/// implementation of `make_new_python_type` in `detail/classes.h` to understand +/// the context in which the callback will be run. +struct custom_type_setup { + using callback = std::function; + + explicit custom_type_setup(callback value) : value(std::move(value)) {} + + callback value; +}; + +/// Annotation that marks a class as local to the module: +struct module_local { + const bool value; + constexpr explicit module_local(bool v = true) : value(v) {} +}; + +/// Annotation to mark enums as an arithmetic type +struct arithmetic {}; + +/// Mark a function for addition at the beginning of the existing overload chain instead of the end +struct prepend {}; + +/** \rst + A call policy which places one or more guard variables (``Ts...``) around the function call. + + For example, this definition: + + .. code-block:: cpp + + m.def("foo", foo, py::call_guard()); + + is equivalent to the following pseudocode: + + .. code-block:: cpp + + m.def("foo", [](args...) { + T scope_guard; + return foo(args...); // forwarded arguments + }); + \endrst */ +template +struct call_guard; + +template <> +struct call_guard<> { + using type = detail::void_type; +}; + +template +struct call_guard { + static_assert(std::is_default_constructible::value, + "The guard type must be default constructible"); + + using type = T; +}; + +template +struct call_guard { + struct type { + T guard{}; // Compose multiple guard types with left-to-right default-constructor order + typename call_guard::type next{}; + }; +}; + +/// @} annotations + +PYBIND11_NAMESPACE_BEGIN(detail) +/* Forward declarations */ +enum op_id : int; +enum op_type : int; +struct undefined_t; +template +struct op_; +void keep_alive_impl(size_t Nurse, size_t Patient, function_call &call, handle ret); + +/// Internal data structure which holds metadata about a keyword argument +struct argument_record { + const char *name; ///< Argument name + const char *descr; ///< Human-readable version of the argument value + handle value; ///< Associated Python object + bool convert : 1; ///< True if the argument is allowed to convert when loading + bool none : 1; ///< True if None is allowed when loading + + argument_record(const char *name, const char *descr, handle value, bool convert, bool none) + : name(name), descr(descr), value(value), convert(convert), none(none) {} +}; + +/// Internal data structure which holds metadata about a bound function (signature, overloads, +/// etc.) +struct function_record { + function_record() + : is_constructor(false), is_new_style_constructor(false), is_stateless(false), + is_operator(false), is_method(false), is_setter(false), has_args(false), + has_kwargs(false), prepend(false) {} + + /// Function name + char *name = nullptr; /* why no C++ strings? They generate heavier code.. */ + + // User-specified documentation string + char *doc = nullptr; + + /// Human-readable version of the function signature + char *signature = nullptr; + + /// List of registered keyword arguments + std::vector args; + + /// Pointer to lambda function which converts arguments and performs the actual call + handle (*impl)(function_call &) = nullptr; + + /// Storage for the wrapped function pointer and captured data, if any + void *data[3] = {}; + + /// Pointer to custom destructor for 'data' (if needed) + void (*free_data)(function_record *ptr) = nullptr; + + /// Return value policy associated with this function + return_value_policy policy = return_value_policy::automatic; + + /// True if name == '__init__' + bool is_constructor : 1; + + /// True if this is a new-style `__init__` defined in `detail/init.h` + bool is_new_style_constructor : 1; + + /// True if this is a stateless function pointer + bool is_stateless : 1; + + /// True if this is an operator (__add__), etc. + bool is_operator : 1; + + /// True if this is a method + bool is_method : 1; + + /// True if this is a setter + bool is_setter : 1; + + /// True if the function has a '*args' argument + bool has_args : 1; + + /// True if the function has a '**kwargs' argument + bool has_kwargs : 1; + + /// True if this function is to be inserted at the beginning of the overload resolution chain + bool prepend : 1; + + /// Number of arguments (including py::args and/or py::kwargs, if present) + std::uint16_t nargs; + + /// Number of leading positional arguments, which are terminated by a py::args or py::kwargs + /// argument or by a py::kw_only annotation. + std::uint16_t nargs_pos = 0; + + /// Number of leading arguments (counted in `nargs`) that are positional-only + std::uint16_t nargs_pos_only = 0; + + /// Python method object + PyMethodDef *def = nullptr; + + /// Python handle to the parent scope (a class or a module) + handle scope; + + /// Python handle to the sibling function representing an overload chain + handle sibling; + + /// Pointer to next overload + function_record *next = nullptr; +}; + +/// Special data structure which (temporarily) holds metadata about a bound class +struct type_record { + PYBIND11_NOINLINE type_record() + : multiple_inheritance(false), dynamic_attr(false), buffer_protocol(false), + default_holder(true), module_local(false), is_final(false) {} + + /// Handle to the parent scope + handle scope; + + /// Name of the class + const char *name = nullptr; + + // Pointer to RTTI type_info data structure + const std::type_info *type = nullptr; + + /// How large is the underlying C++ type? + size_t type_size = 0; + + /// What is the alignment of the underlying C++ type? + size_t type_align = 0; + + /// How large is the type's holder? + size_t holder_size = 0; + + /// The global operator new can be overridden with a class-specific variant + void *(*operator_new)(size_t) = nullptr; + + /// Function pointer to class_<..>::init_instance + void (*init_instance)(instance *, const void *) = nullptr; + + /// Function pointer to class_<..>::dealloc + void (*dealloc)(detail::value_and_holder &) = nullptr; + + /// List of base classes of the newly created type + list bases; + + /// Optional docstring + const char *doc = nullptr; + + /// Custom metaclass (optional) + handle metaclass; + + /// Custom type setup. + custom_type_setup::callback custom_type_setup_callback; + + /// Multiple inheritance marker + bool multiple_inheritance : 1; + + /// Does the class manage a __dict__? + bool dynamic_attr : 1; + + /// Does the class implement the buffer protocol? + bool buffer_protocol : 1; + + /// Is the default (unique_ptr) holder type used? + bool default_holder : 1; + + /// Is the class definition local to the module shared object? + bool module_local : 1; + + /// Is the class inheritable from python classes? + bool is_final : 1; + + PYBIND11_NOINLINE void add_base(const std::type_info &base, void *(*caster)(void *) ) { + auto *base_info = detail::get_type_info(base, false); + if (!base_info) { + std::string tname(base.name()); + detail::clean_type_id(tname); + pybind11_fail("generic_type: type \"" + std::string(name) + + "\" referenced unknown base type \"" + tname + "\""); + } + + if (default_holder != base_info->default_holder) { + std::string tname(base.name()); + detail::clean_type_id(tname); + pybind11_fail("generic_type: type \"" + std::string(name) + "\" " + + (default_holder ? "does not have" : "has") + + " a non-default holder type while its base \"" + tname + "\" " + + (base_info->default_holder ? "does not" : "does")); + } + + bases.append((PyObject *) base_info->type); + +#if PY_VERSION_HEX < 0x030B0000 + dynamic_attr |= base_info->type->tp_dictoffset != 0; +#else + dynamic_attr |= (base_info->type->tp_flags & Py_TPFLAGS_MANAGED_DICT) != 0; +#endif + + if (caster) { + base_info->implicit_casts.emplace_back(type, caster); + } + } +}; + +inline function_call::function_call(const function_record &f, handle p) : func(f), parent(p) { + args.reserve(f.nargs); + args_convert.reserve(f.nargs); +} + +/// Tag for a new-style `__init__` defined in `detail/init.h` +struct is_new_style_constructor {}; + +/** + * Partial template specializations to process custom attributes provided to + * cpp_function_ and class_. These are either used to initialize the respective + * fields in the type_record and function_record data structures or executed at + * runtime to deal with custom call policies (e.g. keep_alive). + */ +template +struct process_attribute; + +template +struct process_attribute_default { + /// Default implementation: do nothing + static void init(const T &, function_record *) {} + static void init(const T &, type_record *) {} + static void precall(function_call &) {} + static void postcall(function_call &, handle) {} +}; + +/// Process an attribute specifying the function's name +template <> +struct process_attribute : process_attribute_default { + static void init(const name &n, function_record *r) { r->name = const_cast(n.value); } +}; + +/// Process an attribute specifying the function's docstring +template <> +struct process_attribute : process_attribute_default { + static void init(const doc &n, function_record *r) { r->doc = const_cast(n.value); } +}; + +/// Process an attribute specifying the function's docstring (provided as a C-style string) +template <> +struct process_attribute : process_attribute_default { + static void init(const char *d, function_record *r) { r->doc = const_cast(d); } + static void init(const char *d, type_record *r) { r->doc = d; } +}; +template <> +struct process_attribute : process_attribute {}; + +/// Process an attribute indicating the function's return value policy +template <> +struct process_attribute : process_attribute_default { + static void init(const return_value_policy &p, function_record *r) { r->policy = p; } +}; + +/// Process an attribute which indicates that this is an overloaded function associated with a +/// given sibling +template <> +struct process_attribute : process_attribute_default { + static void init(const sibling &s, function_record *r) { r->sibling = s.value; } +}; + +/// Process an attribute which indicates that this function is a method +template <> +struct process_attribute : process_attribute_default { + static void init(const is_method &s, function_record *r) { + r->is_method = true; + r->scope = s.class_; + } +}; + +/// Process an attribute which indicates that this function is a setter +template <> +struct process_attribute : process_attribute_default { + static void init(const is_setter &, function_record *r) { r->is_setter = true; } +}; + +/// Process an attribute which indicates the parent scope of a method +template <> +struct process_attribute : process_attribute_default { + static void init(const scope &s, function_record *r) { r->scope = s.value; } +}; + +/// Process an attribute which indicates that this function is an operator +template <> +struct process_attribute : process_attribute_default { + static void init(const is_operator &, function_record *r) { r->is_operator = true; } +}; + +template <> +struct process_attribute + : process_attribute_default { + static void init(const is_new_style_constructor &, function_record *r) { + r->is_new_style_constructor = true; + } +}; + +inline void check_kw_only_arg(const arg &a, function_record *r) { + if (r->args.size() > r->nargs_pos && (!a.name || a.name[0] == '\0')) { + pybind11_fail("arg(): cannot specify an unnamed argument after a kw_only() annotation or " + "args() argument"); + } +} + +inline void append_self_arg_if_needed(function_record *r) { + if (r->is_method && r->args.empty()) { + r->args.emplace_back("self", nullptr, handle(), /*convert=*/true, /*none=*/false); + } +} + +/// Process a keyword argument attribute (*without* a default value) +template <> +struct process_attribute : process_attribute_default { + static void init(const arg &a, function_record *r) { + append_self_arg_if_needed(r); + r->args.emplace_back(a.name, nullptr, handle(), !a.flag_noconvert, a.flag_none); + + check_kw_only_arg(a, r); + } +}; + +/// Process a keyword argument attribute (*with* a default value) +template <> +struct process_attribute : process_attribute_default { + static void init(const arg_v &a, function_record *r) { + if (r->is_method && r->args.empty()) { + r->args.emplace_back( + "self", /*descr=*/nullptr, /*parent=*/handle(), /*convert=*/true, /*none=*/false); + } + + if (!a.value) { +#if defined(PYBIND11_DETAILED_ERROR_MESSAGES) + std::string descr("'"); + if (a.name) { + descr += std::string(a.name) + ": "; + } + descr += a.type + "'"; + if (r->is_method) { + if (r->name) { + descr += " in method '" + (std::string) str(r->scope) + "." + + (std::string) r->name + "'"; + } else { + descr += " in method of '" + (std::string) str(r->scope) + "'"; + } + } else if (r->name) { + descr += " in function '" + (std::string) r->name + "'"; + } + pybind11_fail("arg(): could not convert default argument " + descr + + " into a Python object (type not registered yet?)"); +#else + pybind11_fail("arg(): could not convert default argument " + "into a Python object (type not registered yet?). " + "#define PYBIND11_DETAILED_ERROR_MESSAGES or compile in debug mode for " + "more information."); +#endif + } + r->args.emplace_back(a.name, a.descr, a.value.inc_ref(), !a.flag_noconvert, a.flag_none); + + check_kw_only_arg(a, r); + } +}; + +/// Process a keyword-only-arguments-follow pseudo argument +template <> +struct process_attribute : process_attribute_default { + static void init(const kw_only &, function_record *r) { + append_self_arg_if_needed(r); + if (r->has_args && r->nargs_pos != static_cast(r->args.size())) { + pybind11_fail("Mismatched args() and kw_only(): they must occur at the same relative " + "argument location (or omit kw_only() entirely)"); + } + r->nargs_pos = static_cast(r->args.size()); + } +}; + +/// Process a positional-only-argument maker +template <> +struct process_attribute : process_attribute_default { + static void init(const pos_only &, function_record *r) { + append_self_arg_if_needed(r); + r->nargs_pos_only = static_cast(r->args.size()); + if (r->nargs_pos_only > r->nargs_pos) { + pybind11_fail("pos_only(): cannot follow a py::args() argument"); + } + // It also can't follow a kw_only, but a static_assert in pybind11.h checks that + } +}; + +/// Process a parent class attribute. Single inheritance only (class_ itself already guarantees +/// that) +template +struct process_attribute::value>> + : process_attribute_default { + static void init(const handle &h, type_record *r) { r->bases.append(h); } +}; + +/// Process a parent class attribute (deprecated, does not support multiple inheritance) +template +struct process_attribute> : process_attribute_default> { + static void init(const base &, type_record *r) { r->add_base(typeid(T), nullptr); } +}; + +/// Process a multiple inheritance attribute +template <> +struct process_attribute : process_attribute_default { + static void init(const multiple_inheritance &, type_record *r) { + r->multiple_inheritance = true; + } +}; + +template <> +struct process_attribute : process_attribute_default { + static void init(const dynamic_attr &, type_record *r) { r->dynamic_attr = true; } +}; + +template <> +struct process_attribute { + static void init(const custom_type_setup &value, type_record *r) { + r->custom_type_setup_callback = value.value; + } +}; + +template <> +struct process_attribute : process_attribute_default { + static void init(const is_final &, type_record *r) { r->is_final = true; } +}; + +template <> +struct process_attribute : process_attribute_default { + static void init(const buffer_protocol &, type_record *r) { r->buffer_protocol = true; } +}; + +template <> +struct process_attribute : process_attribute_default { + static void init(const metaclass &m, type_record *r) { r->metaclass = m.value; } +}; + +template <> +struct process_attribute : process_attribute_default { + static void init(const module_local &l, type_record *r) { r->module_local = l.value; } +}; + +/// Process a 'prepend' attribute, putting this at the beginning of the overload chain +template <> +struct process_attribute : process_attribute_default { + static void init(const prepend &, function_record *r) { r->prepend = true; } +}; + +/// Process an 'arithmetic' attribute for enums (does nothing here) +template <> +struct process_attribute : process_attribute_default {}; + +template +struct process_attribute> : process_attribute_default> {}; + +/** + * Process a keep_alive call policy -- invokes keep_alive_impl during the + * pre-call handler if both Nurse, Patient != 0 and use the post-call handler + * otherwise + */ +template +struct process_attribute> + : public process_attribute_default> { + template = 0> + static void precall(function_call &call) { + keep_alive_impl(Nurse, Patient, call, handle()); + } + template = 0> + static void postcall(function_call &, handle) {} + template = 0> + static void precall(function_call &) {} + template = 0> + static void postcall(function_call &call, handle ret) { + keep_alive_impl(Nurse, Patient, call, ret); + } +}; + +/// Recursively iterate over variadic template arguments +template +struct process_attributes { + static void init(const Args &...args, function_record *r) { + PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(r); + PYBIND11_WORKAROUND_INCORRECT_GCC_UNUSED_BUT_SET_PARAMETER(r); + using expander = int[]; + (void) expander{ + 0, ((void) process_attribute::type>::init(args, r), 0)...}; + } + static void init(const Args &...args, type_record *r) { + PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(r); + PYBIND11_WORKAROUND_INCORRECT_GCC_UNUSED_BUT_SET_PARAMETER(r); + using expander = int[]; + (void) expander{0, + (process_attribute::type>::init(args, r), 0)...}; + } + static void precall(function_call &call) { + PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(call); + using expander = int[]; + (void) expander{0, + (process_attribute::type>::precall(call), 0)...}; + } + static void postcall(function_call &call, handle fn_ret) { + PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(call, fn_ret); + PYBIND11_WORKAROUND_INCORRECT_GCC_UNUSED_BUT_SET_PARAMETER(fn_ret); + using expander = int[]; + (void) expander{ + 0, (process_attribute::type>::postcall(call, fn_ret), 0)...}; + } +}; + +template +using is_call_guard = is_instantiation; + +/// Extract the ``type`` from the first `call_guard` in `Extras...` (or `void_type` if none found) +template +using extract_guard_t = typename exactly_one_t, Extra...>::type; + +/// Check the number of named arguments at compile time +template ::value...), + size_t self = constexpr_sum(std::is_same::value...)> +constexpr bool expected_num_args(size_t nargs, bool has_args, bool has_kwargs) { + PYBIND11_WORKAROUND_INCORRECT_MSVC_C4100(nargs, has_args, has_kwargs); + return named == 0 || (self + named + size_t(has_args) + size_t(has_kwargs)) == nargs; +} + +PYBIND11_NAMESPACE_END(detail) +PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/buffer_info.h b/lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/buffer_info.h new file mode 100644 index 000000000..b99ee8bef --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/buffer_info.h @@ -0,0 +1,208 @@ +/* + pybind11/buffer_info.h: Python buffer object interface + + Copyright (c) 2016 Wenzel Jakob + + All rights reserved. Use of this source code is governed by a + BSD-style license that can be found in the LICENSE file. +*/ + +#pragma once + +#include "detail/common.h" + +PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) + +PYBIND11_NAMESPACE_BEGIN(detail) + +// Default, C-style strides +inline std::vector c_strides(const std::vector &shape, ssize_t itemsize) { + auto ndim = shape.size(); + std::vector strides(ndim, itemsize); + if (ndim > 0) { + for (size_t i = ndim - 1; i > 0; --i) { + strides[i - 1] = strides[i] * shape[i]; + } + } + return strides; +} + +// F-style strides; default when constructing an array_t with `ExtraFlags & f_style` +inline std::vector f_strides(const std::vector &shape, ssize_t itemsize) { + auto ndim = shape.size(); + std::vector strides(ndim, itemsize); + for (size_t i = 1; i < ndim; ++i) { + strides[i] = strides[i - 1] * shape[i - 1]; + } + return strides; +} + +template +struct compare_buffer_info; + +PYBIND11_NAMESPACE_END(detail) + +/// Information record describing a Python buffer object +struct buffer_info { + void *ptr = nullptr; // Pointer to the underlying storage + ssize_t itemsize = 0; // Size of individual items in bytes + ssize_t size = 0; // Total number of entries + std::string format; // For homogeneous buffers, this should be set to + // format_descriptor::format() + ssize_t ndim = 0; // Number of dimensions + std::vector shape; // Shape of the tensor (1 entry per dimension) + std::vector strides; // Number of bytes between adjacent entries + // (for each per dimension) + bool readonly = false; // flag to indicate if the underlying storage may be written to + + buffer_info() = default; + + buffer_info(void *ptr, + ssize_t itemsize, + const std::string &format, + ssize_t ndim, + detail::any_container shape_in, + detail::any_container strides_in, + bool readonly = false) + : ptr(ptr), itemsize(itemsize), size(1), format(format), ndim(ndim), + shape(std::move(shape_in)), strides(std::move(strides_in)), readonly(readonly) { + if (ndim != (ssize_t) shape.size() || ndim != (ssize_t) strides.size()) { + pybind11_fail("buffer_info: ndim doesn't match shape and/or strides length"); + } + for (size_t i = 0; i < (size_t) ndim; ++i) { + size *= shape[i]; + } + } + + template + buffer_info(T *ptr, + detail::any_container shape_in, + detail::any_container strides_in, + bool readonly = false) + : buffer_info(private_ctr_tag(), + ptr, + sizeof(T), + format_descriptor::format(), + static_cast(shape_in->size()), + std::move(shape_in), + std::move(strides_in), + readonly) {} + + buffer_info(void *ptr, + ssize_t itemsize, + const std::string &format, + ssize_t size, + bool readonly = false) + : buffer_info(ptr, itemsize, format, 1, {size}, {itemsize}, readonly) {} + + template + buffer_info(T *ptr, ssize_t size, bool readonly = false) + : buffer_info(ptr, sizeof(T), format_descriptor::format(), size, readonly) {} + + template + buffer_info(const T *ptr, ssize_t size, bool readonly = true) + : buffer_info( + const_cast(ptr), sizeof(T), format_descriptor::format(), size, readonly) {} + + explicit buffer_info(Py_buffer *view, bool ownview = true) + : buffer_info( + view->buf, + view->itemsize, + view->format, + view->ndim, + {view->shape, view->shape + view->ndim}, + /* Though buffer::request() requests PyBUF_STRIDES, ctypes objects + * ignore this flag and return a view with NULL strides. + * When strides are NULL, build them manually. */ + view->strides + ? std::vector(view->strides, view->strides + view->ndim) + : detail::c_strides({view->shape, view->shape + view->ndim}, view->itemsize), + (view->readonly != 0)) { + // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer) + this->m_view = view; + // NOLINTNEXTLINE(cppcoreguidelines-prefer-member-initializer) + this->ownview = ownview; + } + + buffer_info(const buffer_info &) = delete; + buffer_info &operator=(const buffer_info &) = delete; + + buffer_info(buffer_info &&other) noexcept { (*this) = std::move(other); } + + buffer_info &operator=(buffer_info &&rhs) noexcept { + ptr = rhs.ptr; + itemsize = rhs.itemsize; + size = rhs.size; + format = std::move(rhs.format); + ndim = rhs.ndim; + shape = std::move(rhs.shape); + strides = std::move(rhs.strides); + std::swap(m_view, rhs.m_view); + std::swap(ownview, rhs.ownview); + readonly = rhs.readonly; + return *this; + } + + ~buffer_info() { + if (m_view && ownview) { + PyBuffer_Release(m_view); + delete m_view; + } + } + + Py_buffer *view() const { return m_view; } + Py_buffer *&view() { return m_view; } + + /* True if the buffer item type is equivalent to `T`. */ + // To define "equivalent" by example: + // `buffer_info::item_type_is_equivalent_to(b)` and + // `buffer_info::item_type_is_equivalent_to(b)` may both be true + // on some platforms, but `int` and `unsigned` will never be equivalent. + // For the ground truth, please inspect `detail::compare_buffer_info<>`. + template + bool item_type_is_equivalent_to() const { + return detail::compare_buffer_info::compare(*this); + } + +private: + struct private_ctr_tag {}; + + buffer_info(private_ctr_tag, + void *ptr, + ssize_t itemsize, + const std::string &format, + ssize_t ndim, + detail::any_container &&shape_in, + detail::any_container &&strides_in, + bool readonly) + : buffer_info( + ptr, itemsize, format, ndim, std::move(shape_in), std::move(strides_in), readonly) {} + + Py_buffer *m_view = nullptr; + bool ownview = false; +}; + +PYBIND11_NAMESPACE_BEGIN(detail) + +template +struct compare_buffer_info { + static bool compare(const buffer_info &b) { + // NOLINTNEXTLINE(bugprone-sizeof-expression) Needed for `PyObject *` + return b.format == format_descriptor::format() && b.itemsize == (ssize_t) sizeof(T); + } +}; + +template +struct compare_buffer_info::value>> { + static bool compare(const buffer_info &b) { + return (size_t) b.itemsize == sizeof(T) + && (b.format == format_descriptor::value + || ((sizeof(T) == sizeof(long)) + && b.format == (std::is_unsigned::value ? "L" : "l")) + || ((sizeof(T) == sizeof(size_t)) + && b.format == (std::is_unsigned::value ? "N" : "n"))); + } +}; + +PYBIND11_NAMESPACE_END(detail) +PYBIND11_NAMESPACE_END(PYBIND11_NAMESPACE) diff --git a/lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/cast.h b/lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/cast.h new file mode 100644 index 000000000..db3934118 --- /dev/null +++ b/lzero/mcts/ctree/ctree_alphazero/pybind11/include/pybind11/cast.h @@ -0,0 +1,1704 @@ +/* + pybind11/cast.h: Partial template specializations to cast between + C++ and Python types + + Copyright (c) 2016 Wenzel Jakob + + All rights reserved. Use of this source code is governed by a + BSD-style license that can be found in the LICENSE file. +*/ + +#pragma once + +#include "detail/common.h" +#include "detail/descr.h" +#include "detail/type_caster_base.h" +#include "detail/typeid.h" +#include "pytypes.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +PYBIND11_NAMESPACE_BEGIN(PYBIND11_NAMESPACE) + +PYBIND11_WARNING_DISABLE_MSVC(4127) + +PYBIND11_NAMESPACE_BEGIN(detail) + +template +class type_caster : public type_caster_base {}; +template +using make_caster = type_caster>; + +// Shortcut for calling a caster's `cast_op_type` cast operator for casting a type_caster to a T +template +typename make_caster::template cast_op_type cast_op(make_caster &caster) { + return caster.operator typename make_caster::template cast_op_type(); +} +template +typename make_caster::template cast_op_type::type> +cast_op(make_caster &&caster) { + return std::move(caster).operator typename make_caster:: + template cast_op_type::type>(); +} + +template +class type_caster> { +private: + using caster_t = make_caster; + caster_t subcaster; + using reference_t = type &; + using subcaster_cast_op_type = typename caster_t::template cast_op_type; + + static_assert( + std::is_same::type &, subcaster_cast_op_type>::value + || std::is_same::value, + "std::reference_wrapper caster requires T to have a caster with an " + "`operator T &()` or `operator const T &()`"); + +public: + bool load(handle src, bool convert) { return subcaster.load(src, convert); } + static constexpr auto name = caster_t::name; + static handle + cast(const std::reference_wrapper &src, return_value_policy policy, handle parent) { + // It is definitely wrong to take ownership of this pointer, so mask that rvp + if (policy == return_value_policy::take_ownership + || policy == return_value_policy::automatic) { + policy = return_value_policy::automatic_reference; + } + return caster_t::cast(&src.get(), policy, parent); + } + template + using cast_op_type = std::reference_wrapper; + explicit operator std::reference_wrapper() { return cast_op(subcaster); } +}; + +#define PYBIND11_TYPE_CASTER(type, py_name) \ +protected: \ + type value; \ + \ +public: \ + static constexpr auto name = py_name; \ + template >::value, \ + int> \ + = 0> \ + static ::pybind11::handle cast( \ + T_ *src, ::pybind11::return_value_policy policy, ::pybind11::handle parent) { \ + if (!src) \ + return ::pybind11::none().release(); \ + if (policy == ::pybind11::return_value_policy::take_ownership) { \ + auto h = cast(std::move(*src), policy, parent); \ + delete src; \ + return h; \ + } \ + return cast(*src, policy, parent); \ + } \ + operator type *() { return &value; } /* NOLINT(bugprone-macro-parentheses) */ \ + operator type &() { return value; } /* NOLINT(bugprone-macro-parentheses) */ \ + operator type &&() && { return std::move(value); } /* NOLINT(bugprone-macro-parentheses) */ \ + template \ + using cast_op_type = ::pybind11::detail::movable_cast_op_type + +template +using is_std_char_type = any_of, /* std::string */ +#if defined(PYBIND11_HAS_U8STRING) + std::is_same, /* std::u8string */ +#endif + std::is_same, /* std::u16string */ + std::is_same, /* std::u32string */ + std::is_same /* std::wstring */ + >; + +template +struct type_caster::value && !is_std_char_type::value>> { + using _py_type_0 = conditional_t; + using _py_type_1 = conditional_t::value, + _py_type_0, + typename std::make_unsigned<_py_type_0>::type>; + using py_type = conditional_t::value, double, _py_type_1>; + +public: + bool load(handle src, bool convert) { + py_type py_value; + + if (!src) { + return false; + } + +#if !defined(PYPY_VERSION) + auto index_check = [](PyObject *o) { return PyIndex_Check(o); }; +#else + // In PyPy 7.3.3, `PyIndex_Check` is implemented by calling `__index__`, + // while CPython only considers the existence of `nb_index`/`__index__`. + auto index_check = [](PyObject *o) { return hasattr(o, "__index__"); }; +#endif + + if (std::is_floating_point::value) { + if (convert || PyFloat_Check(src.ptr())) { + py_value = (py_type) PyFloat_AsDouble(src.ptr()); + } else { + return false; + } + } else if (PyFloat_Check(src.ptr()) + || (!convert && !PYBIND11_LONG_CHECK(src.ptr()) && !index_check(src.ptr()))) { + return false; + } else { + handle src_or_index = src; + // PyPy: 7.3.7's 3.8 does not implement PyLong_*'s __index__ calls. +#if PY_VERSION_HEX < 0x03080000 || defined(PYPY_VERSION) + object index; + if (!PYBIND11_LONG_CHECK(src.ptr())) { // So: index_check(src.ptr()) + index = reinterpret_steal(PyNumber_Index(src.ptr())); + if (!index) { + PyErr_Clear(); + if (!convert) + return false; + } else { + src_or_index = index; + } + } +#endif + if (std::is_unsigned::value) { + py_value = as_unsigned(src_or_index.ptr()); + } else { // signed integer: + py_value = sizeof(T) <= sizeof(long) + ? (py_type) PyLong_AsLong(src_or_index.ptr()) + : (py_type) PYBIND11_LONG_AS_LONGLONG(src_or_index.ptr()); + } + } + + // Python API reported an error + bool py_err = py_value == (py_type) -1 && PyErr_Occurred(); + + // Check to see if the conversion is valid (integers should match exactly) + // Signed/unsigned checks happen elsewhere + if (py_err + || (std::is_integral::value && sizeof(py_type) != sizeof(T) + && py_value != (py_type) (T) py_value)) { + PyErr_Clear(); + if (py_err && convert && (PyNumber_Check(src.ptr()) != 0)) { + auto tmp = reinterpret_steal(std::is_floating_point::value + ? PyNumber_Float(src.ptr()) + : PyNumber_Long(src.ptr())); + PyErr_Clear(); + return load(tmp, false); + } + return false; + } + + value = (T) py_value; + return true; + } + + template + static typename std::enable_if::value, handle>::type + cast(U src, return_value_policy /* policy */, handle /* parent */) { + return PyFloat_FromDouble((double) src); + } + + template + static typename std::enable_if::value && std::is_signed::value + && (sizeof(U) <= sizeof(long)), + handle>::type + cast(U src, return_value_policy /* policy */, handle /* parent */) { + return PYBIND11_LONG_FROM_SIGNED((long) src); + } + + template + static typename std::enable_if::value && std::is_unsigned::value + && (sizeof(U) <= sizeof(unsigned long)), + handle>::type + cast(U src, return_value_policy /* policy */, handle /* parent */) { + return PYBIND11_LONG_FROM_UNSIGNED((unsigned long) src); + } + + template + static typename std::enable_if::value && std::is_signed::value + && (sizeof(U) > sizeof(long)), + handle>::type + cast(U src, return_value_policy /* policy */, handle /* parent */) { + return PyLong_FromLongLong((long long) src); + } + + template + static typename std::enable_if::value && std::is_unsigned::value + && (sizeof(U) > sizeof(unsigned long)), + handle>::type + cast(U src, return_value_policy /* policy */, handle /* parent */) { + return PyLong_FromUnsignedLongLong((unsigned long long) src); + } + + PYBIND11_TYPE_CASTER(T, const_name::value>("int", "float")); +}; + +template +struct void_caster { +public: + bool load(handle src, bool) { + if (src && src.is_none()) { + return true; + } + return false; + } + static handle cast(T, return_value_policy /* policy */, handle /* parent */) { + return none().release(); + } + PYBIND11_TYPE_CASTER(T, const_name("None")); +}; + +template <> +class type_caster : public void_caster {}; + +template <> +class type_caster : public type_caster { +public: + using type_caster::cast; + + bool load(handle h, bool) { + if (!h) { + return false; + } + if (h.is_none()) { + value = nullptr; + return true; + } + + /* Check if this is a capsule */ + if (isinstance(h)) { + value = reinterpret_borrow(h); + return true; + } + + /* Check if this is a C++ type */ + const auto &bases = all_type_info((PyTypeObject *) type::handle_of(h).ptr()); + if (bases.size() == 1) { // Only allowing loading from a single-value type + value = values_and_holders(reinterpret_cast(h.ptr())).begin()->value_ptr(); + return true; + } + + /* Fail */ + return false; + } + + static handle cast(const void *ptr, return_value_policy /* policy */, handle /* parent */) { + if (ptr) { + return capsule(ptr).release(); + } + return none().release(); + } + + template + using cast_op_type = void *&; + explicit operator void *&() { return value; } + static constexpr auto name = const_name("capsule"); + +private: + void *value = nullptr; +}; + +template <> +class type_caster : public void_caster {}; + +template <> +class type_caster { +public: + bool load(handle src, bool convert) { + if (!src) { + return false; + } + if (src.ptr() == Py_True) { + value = true; + return true; + } + if (src.ptr() == Py_False) { + value = false; + return true; + } + if (convert || (std::strcmp("numpy.bool_", Py_TYPE(src.ptr())->tp_name) == 0)) { + // (allow non-implicit conversion for numpy booleans) + + Py_ssize_t res = -1; + if (src.is_none()) { + res = 0; // None is implicitly converted to False + } +#if defined(PYPY_VERSION) + // On PyPy, check that "__bool__" attr exists + else if (hasattr(src, PYBIND11_BOOL_ATTR)) { + res = PyObject_IsTrue(src.ptr()); + } +#else + // Alternate approach for CPython: this does the same as the above, but optimized + // using the CPython API so as to avoid an unneeded attribute lookup. + else if (auto *tp_as_number = src.ptr()->ob_type->tp_as_number) { + if (PYBIND11_NB_BOOL(tp_as_number)) { + res = (*PYBIND11_NB_BOOL(tp_as_number))(src.ptr()); + } + } +#endif + if (res == 0 || res == 1) { + value = (res != 0); + return true; + } + PyErr_Clear(); + } + return false; + } + static handle cast(bool src, return_value_policy /* policy */, handle /* parent */) { + return handle(src ? Py_True : Py_False).inc_ref(); + } + PYBIND11_TYPE_CASTER(bool, const_name("bool")); +}; + +// Helper class for UTF-{8,16,32} C++ stl strings: +template +struct string_caster { + using CharT = typename StringType::value_type; + + // Simplify life by being able to assume standard char sizes (the standard only guarantees + // minimums, but Python requires exact sizes) + static_assert(!std::is_same::value || sizeof(CharT) == 1, + "Unsupported char size != 1"); +#if defined(PYBIND11_HAS_U8STRING) + static_assert(!std::is_same::value || sizeof(CharT) == 1, + "Unsupported char8_t size != 1"); +#endif + static_assert(!std::is_same::value || sizeof(CharT) == 2, + "Unsupported char16_t size != 2"); + static_assert(!std::is_same::value || sizeof(CharT) == 4, + "Unsupported char32_t size != 4"); + // wchar_t can be either 16 bits (Windows) or 32 (everywhere else) + static_assert(!std::is_same::value || sizeof(CharT) == 2 || sizeof(CharT) == 4, + "Unsupported wchar_t size != 2/4"); + static constexpr size_t UTF_N = 8 * sizeof(CharT); + + bool load(handle src, bool) { + handle load_src = src; + if (!src) { + return false; + } + if (!PyUnicode_Check(load_src.ptr())) { + return load_raw(load_src); + } + + // For UTF-8 we avoid the need for a temporary `bytes` object by using + // `PyUnicode_AsUTF8AndSize`. + if (UTF_N == 8) { + Py_ssize_t size = -1; + const auto *buffer + = reinterpret_cast(PyUnicode_AsUTF8AndSize(load_src.ptr(), &size)); + if (!buffer) { + PyErr_Clear(); + return false; + } + value = StringType(buffer, static_cast(size)); + return true; + } + + auto utfNbytes + = reinterpret_steal(PyUnicode_AsEncodedString(load_src.ptr(), + UTF_N == 8 ? "utf-8" + : UTF_N == 16 ? "utf-16" + : "utf-32", + nullptr)); + if (!utfNbytes) { + PyErr_Clear(); + return false; + } + + const auto *buffer + = reinterpret_cast(PYBIND11_BYTES_AS_STRING(utfNbytes.ptr())); + size_t length = (size_t) PYBIND11_BYTES_SIZE(utfNbytes.ptr()) / sizeof(CharT); + // Skip BOM for UTF-16/32 + if (UTF_N > 8) { + buffer++; + length--; + } + value = StringType(buffer, length); + + // If we're loading a string_view we need to keep the encoded Python object alive: + if (IsView) { + loader_life_support::add_patient(utfNbytes); + } + + return true; + } + + static handle + cast(const StringType &src, return_value_policy /* policy */, handle /* parent */) { + const char *buffer = reinterpret_cast(src.data()); + auto nbytes = ssize_t(src.size() * sizeof(CharT)); + handle s = decode_utfN(buffer, nbytes); + if (!s) { + throw error_already_set(); + } + return s; + } + + PYBIND11_TYPE_CASTER(StringType, const_name(PYBIND11_STRING_NAME)); + +private: + static handle decode_utfN(const char *buffer, ssize_t nbytes) { +#if !defined(PYPY_VERSION) + return UTF_N == 8 ? PyUnicode_DecodeUTF8(buffer, nbytes, nullptr) + : UTF_N == 16 ? PyUnicode_DecodeUTF16(buffer, nbytes, nullptr, nullptr) + : PyUnicode_DecodeUTF32(buffer, nbytes, nullptr, nullptr); +#else + // PyPy segfaults when on PyUnicode_DecodeUTF16 (and possibly on PyUnicode_DecodeUTF32 as + // well), so bypass the whole thing by just passing the encoding as a string value, which + // works properly: + return PyUnicode_Decode(buffer, + nbytes, + UTF_N == 8 ? "utf-8" + : UTF_N == 16 ? "utf-16" + : "utf-32", + nullptr); +#endif + } + + // When loading into a std::string or char*, accept a bytes/bytearray object as-is (i.e. + // without any encoding/decoding attempt). For other C++ char sizes this is a no-op. + // which supports loading a unicode from a str, doesn't take this path. + template + bool load_raw(enable_if_t::value, handle> src) { + if (PYBIND11_BYTES_CHECK(src.ptr())) { + // We were passed raw bytes; accept it into a std::string or char* + // without any encoding attempt. + const char *bytes = PYBIND11_BYTES_AS_STRING(src.ptr()); + if (!bytes) { + pybind11_fail("Unexpected PYBIND11_BYTES_AS_STRING() failure."); + } + value = StringType(bytes, (size_t) PYBIND11_BYTES_SIZE(src.ptr())); + return true; + } + if (PyByteArray_Check(src.ptr())) { + // We were passed a bytearray; accept it into a std::string or char* + // without any encoding attempt. + const char *bytearray = PyByteArray_AsString(src.ptr()); + if (!bytearray) { + pybind11_fail("Unexpected PyByteArray_AsString() failure."); + } + value = StringType(bytearray, (size_t) PyByteArray_Size(src.ptr())); + return true; + } + + return false; + } + + template + bool load_raw(enable_if_t::value, handle>) { + return false; + } +}; + +template +struct type_caster, + enable_if_t::value>> + : string_caster> {}; + +#ifdef PYBIND11_HAS_STRING_VIEW +template +struct type_caster, + enable_if_t::value>> + : string_caster, true> {}; +#endif + +// Type caster for C-style strings. We basically use a std::string type caster, but also add the +// ability to use None as a nullptr char* (which the string caster doesn't allow). +template +struct type_caster::value>> { + using StringType = std::basic_string; + using StringCaster = make_caster; + StringCaster str_caster; + bool none = false; + CharT one_char = 0; + +public: + bool load(handle src, bool convert) { + if (!src) { + return false; + } + if (src.is_none()) { + // Defer accepting None to other overloads (if we aren't in convert mode): + if (!convert) { + return false; + } + none = true; + return true; + } + return str_caster.load(src, convert); + } + + static handle cast(const CharT *src, return_value_policy policy, handle parent) { + if (src == nullptr) { + return pybind11::none().release(); + } + return StringCaster::cast(StringType(src), policy, parent); + } + + static handle cast(CharT src, return_value_policy policy, handle parent) { + if (std::is_same::value) { + handle s = PyUnicode_DecodeLatin1((const char *) &src, 1, nullptr); + if (!s) { + throw error_already_set(); + } + return s; + } + return StringCaster::cast(StringType(1, src), policy, parent); + } + + explicit operator CharT *() { + return none ? nullptr : const_cast(static_cast(str_caster).c_str()); + } + explicit operator CharT &() { + if (none) { + throw value_error("Cannot convert None to a character"); + } + + auto &value = static_cast(str_caster); + size_t str_len = value.size(); + if (str_len == 0) { + throw value_error("Cannot convert empty string to a character"); + } + + // If we're in UTF-8 mode, we have two possible failures: one for a unicode character that + // is too high, and one for multiple unicode characters (caught later), so we need to + // figure out how long the first encoded character is in bytes to distinguish between these + // two errors. We also allow want to allow unicode characters U+0080 through U+00FF, as + // those can fit into a single char value. + if (StringCaster::UTF_N == 8 && str_len > 1 && str_len <= 4) { + auto v0 = static_cast(value[0]); + // low bits only: 0-127 + // 0b110xxxxx - start of 2-byte sequence + // 0b1110xxxx - start of 3-byte sequence + // 0b11110xxx - start of 4-byte sequence + size_t char0_bytes = (v0 & 0x80) == 0 ? 1 + : (v0 & 0xE0) == 0xC0 ? 2 + : (v0 & 0xF0) == 0xE0 ? 3 + : 4; + + if (char0_bytes == str_len) { + // If we have a 128-255 value, we can decode it into a single char: + if (char0_bytes == 2 && (v0 & 0xFC) == 0xC0) { // 0x110000xx 0x10xxxxxx + one_char = static_cast(((v0 & 3) << 6) + + (static_cast(value[1]) & 0x3F)); + return one_char; + } + // Otherwise we have a single character, but it's > U+00FF + throw value_error("Character code point not in range(0x100)"); + } + } + + // UTF-16 is much easier: we can only have a surrogate pair for values above U+FFFF, thus a + // surrogate pair with total length 2 instantly indicates a range error (but not a "your + // string was too long" error). + else if (StringCaster::UTF_N == 16 && str_len == 2) { + one_char = static_cast(value[0]); + if (one_char >= 0xD800 && one_char < 0xE000) { + throw value_error("Character code point not in range(0x10000)"); + } + } + + if (str_len != 1) { + throw value_error("Expected a character, but multi-character string found"); + } + + one_char = value[0]; + return one_char; + } + + static constexpr auto name = const_name(PYBIND11_STRING_NAME); + template + using cast_op_type = pybind11::detail::cast_op_type<_T>; +}; + +// Base implementation for std::tuple and std::pair +template