From c14a98fbcad8bf134683418252b823b117fadc0d Mon Sep 17 00:00:00 2001 From: "mattlamb227@gmail.com" Date: Thu, 13 Aug 2026 23:09:08 -0400 Subject: [PATCH] updated to use optimized cyython build --- src/blokus_gym.egg-info/PKG-INFO | 35 - src/blokus_gym.egg-info/SOURCES.txt | 30 - src/blokus_gym.egg-info/dependency_links.txt | 1 - src/blokus_gym.egg-info/requires.txt | 20 - src/blokus_gym.egg-info/top_level.txt | 2 - .../__pycache__/__init__.cpython-311.pyc | Bin 1186 -> 0 bytes src/blokus_gym/core/__init__.py | 41 +- .../core/__pycache__/__init__.cpython-311.pyc | Bin 889 -> 0 bytes .../core/__pycache__/__init__.cpython-312.pyc | Bin 745 -> 946 bytes .../core/__pycache__/board.cpython-311.pyc | Bin 6506 -> 0 bytes .../core/__pycache__/board.cpython-312.pyc | Bin 6441 -> 6570 bytes .../core/__pycache__/bots.cpython-311.pyc | Bin 9326 -> 0 bytes .../core/__pycache__/game.cpython-311.pyc | Bin 22665 -> 0 bytes .../core/__pycache__/game.cpython-312.pyc | Bin 21724 -> 21726 bytes .../core/__pycache__/pieces.cpython-311.pyc | Bin 15764 -> 0 bytes src/blokus_gym/core/blokus_cython.c | 61414 ++++++++++++++++ ...kus_cython.cpython-312-x86_64-linux-gnu.so | Bin 0 -> 513456 bytes src/blokus_gym/core/blokus_cython.pyx | 801 + src/blokus_gym/core/board.py | 18 +- ...kus_cython.cpython-312-x86_64-linux-gnu.so | Bin 0 -> 503280 bytes .../blokus_cython.o | Bin 0 -> 740008 bytes src/blokus_gym/core/game.py | 4 +- src/blokus_gym/core/setup_cython.py | 25 + ...kus_cython.cpython-312-x86_64-linux-gnu.so | Bin 0 -> 513456 bytes .../blokus_gym/core/blokus_cython.o | Bin 0 -> 751832 bytes src/setup.py | 26 + 26 files changed, 62307 insertions(+), 110 deletions(-) delete mode 100644 src/blokus_gym.egg-info/PKG-INFO delete mode 100644 src/blokus_gym.egg-info/SOURCES.txt delete mode 100644 src/blokus_gym.egg-info/dependency_links.txt delete mode 100644 src/blokus_gym.egg-info/requires.txt delete mode 100644 src/blokus_gym.egg-info/top_level.txt delete mode 100644 src/blokus_gym/__pycache__/__init__.cpython-311.pyc delete mode 100644 src/blokus_gym/core/__pycache__/__init__.cpython-311.pyc delete mode 100644 src/blokus_gym/core/__pycache__/board.cpython-311.pyc delete mode 100644 src/blokus_gym/core/__pycache__/bots.cpython-311.pyc delete mode 100644 src/blokus_gym/core/__pycache__/game.cpython-311.pyc delete mode 100644 src/blokus_gym/core/__pycache__/pieces.cpython-311.pyc create mode 100644 src/blokus_gym/core/blokus_cython.c create mode 100755 src/blokus_gym/core/blokus_cython.cpython-312-x86_64-linux-gnu.so create mode 100644 src/blokus_gym/core/blokus_cython.pyx create mode 100755 src/blokus_gym/core/build/lib.linux-x86_64-cpython-312/blokus_cython.cpython-312-x86_64-linux-gnu.so create mode 100644 src/blokus_gym/core/build/temp.linux-x86_64-cpython-312/blokus_cython.o create mode 100644 src/blokus_gym/core/setup_cython.py create mode 100755 src/build/lib.linux-x86_64-cpython-312/blokus_gym/core/blokus_cython.cpython-312-x86_64-linux-gnu.so create mode 100644 src/build/temp.linux-x86_64-cpython-312/blokus_gym/core/blokus_cython.o create mode 100644 src/setup.py diff --git a/src/blokus_gym.egg-info/PKG-INFO b/src/blokus_gym.egg-info/PKG-INFO deleted file mode 100644 index 4e49f08..0000000 --- a/src/blokus_gym.egg-info/PKG-INFO +++ /dev/null @@ -1,35 +0,0 @@ -Metadata-Version: 2.4 -Name: blokus-gym -Version: 0.1.0 -Summary: A Gymnasium-compatible RL environment for the board game Blokus, with a playable web UI -Author: Blokus Gym Contributors -License: MIT -Project-URL: Homepage, https://github.com/blokus-gym/blokus-gym -Project-URL: Documentation, https://github.com/blokus-gym/blokus-gym#readme -Keywords: reinforcement-learning,gymnasium,blokus,board-game,pettingzoo,flask,game-ui -Classifier: Development Status :: 3 - Alpha -Classifier: Intended Audience :: Science/Research -Classifier: License :: OSI Approved :: MIT License -Classifier: Programming Language :: Python :: 3 -Classifier: Programming Language :: Python :: 3.10 -Classifier: Programming Language :: Python :: 3.11 -Classifier: Programming Language :: Python :: 3.12 -Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence -Requires-Python: >=3.10 -Description-Content-Type: text/markdown -Requires-Dist: numpy>=1.24 -Requires-Dist: gymnasium>=0.29 -Requires-Dist: pettingzoo>=1.26 -Provides-Extra: render -Requires-Dist: matplotlib>=3.7; extra == "render" -Provides-Extra: ui -Requires-Dist: flask>=3.0; extra == "ui" -Provides-Extra: dev -Requires-Dist: pytest>=7.4; extra == "dev" -Requires-Dist: pytest-cov>=4.1; extra == "dev" -Requires-Dist: black>=23.7; extra == "dev" -Requires-Dist: ruff>=0.1.0; extra == "dev" -Requires-Dist: mypy>=1.5; extra == "dev" -Provides-Extra: train -Requires-Dist: stable-baselines3>=2.2; extra == "train" -Requires-Dist: torch>=2.0; extra == "train" diff --git a/src/blokus_gym.egg-info/SOURCES.txt b/src/blokus_gym.egg-info/SOURCES.txt deleted file mode 100644 index 46c5788..0000000 --- a/src/blokus_gym.egg-info/SOURCES.txt +++ /dev/null @@ -1,30 +0,0 @@ -pyproject.toml -src/blokus_gym/__init__.py -src/blokus_gym.egg-info/PKG-INFO -src/blokus_gym.egg-info/SOURCES.txt -src/blokus_gym.egg-info/dependency_links.txt -src/blokus_gym.egg-info/entry_points.txt -src/blokus_gym.egg-info/requires.txt -src/blokus_gym.egg-info/top_level.txt -src/blokus_gym/core/__init__.py -src/blokus_gym/core/board.py -src/blokus_gym/core/bots.py -src/blokus_gym/core/game.py -src/blokus_gym/core/pieces.py -src/blokus_gym/envs/__init__.py -src/blokus_gym/envs/blokus_env.py -src/blokus_gym/envs/multiagent.py -src/blokus_gym/utils/__init__.py -src/blokus_gym/utils/render.py -src/blokus_gym/wrappers/__init__.py -src/blokus_gym/wrappers/action_mask.py -src/blokus_ui/__init__.py -src/blokus_ui/app.py -src/blokus_ui/session.py -src/blokus_ui/store.py -tests/test_board.py -tests/test_envs.py -tests/test_game.py -tests/test_imports.py -tests/test_pieces.py -tests/test_ui.py \ No newline at end of file diff --git a/src/blokus_gym.egg-info/dependency_links.txt b/src/blokus_gym.egg-info/dependency_links.txt deleted file mode 100644 index 8b13789..0000000 --- a/src/blokus_gym.egg-info/dependency_links.txt +++ /dev/null @@ -1 +0,0 @@ - diff --git a/src/blokus_gym.egg-info/requires.txt b/src/blokus_gym.egg-info/requires.txt deleted file mode 100644 index f7a83f7..0000000 --- a/src/blokus_gym.egg-info/requires.txt +++ /dev/null @@ -1,20 +0,0 @@ -numpy>=1.24 -gymnasium>=0.29 -pettingzoo>=1.26 - -[dev] -pytest>=7.4 -pytest-cov>=4.1 -black>=23.7 -ruff>=0.1.0 -mypy>=1.5 - -[render] -matplotlib>=3.7 - -[train] -stable-baselines3>=2.2 -torch>=2.0 - -[ui] -flask>=3.0 diff --git a/src/blokus_gym.egg-info/top_level.txt b/src/blokus_gym.egg-info/top_level.txt deleted file mode 100644 index 2ec0ac8..0000000 --- a/src/blokus_gym.egg-info/top_level.txt +++ /dev/null @@ -1,2 +0,0 @@ -blokus_gym -blokus_ui diff --git a/src/blokus_gym/__pycache__/__init__.cpython-311.pyc b/src/blokus_gym/__pycache__/__init__.cpython-311.pyc deleted file mode 100644 index e4b8c9b6555c1a8c9bc8bcb4a51e35f1bec70625..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 1186 zcmcIizi-+=6g~sSV8U-m({zYBRhBA~tW{eH0*X?JBnpjM-Ewm93DNj$baqJTl)oWE zyJxBT-!P(^Ds}3Hlr2;5or3~Nhb}!ofBxS6c<PS_ zb0x_)ouzS_8Q4&3NiV~)ILl0IDnI4r*cx7Ad7Nhj zTwq09WF=f;Wn5+zTv2;;ugYq;rg++`vvs_#xZyov8+b$V41PL5ZuVNko37bIR_-?x zXlX)k1rB#DT_jsUB(i&)Qg;Hh6w}>+`;><;V|IuBkU5{##$(5K1171J5N68@&d$R< zhf$I024iX&!fc-$lB503Zl@>m?@kW(504javG=}t&~6^L7Zdu?koKu4sm~!FQa^H{ zVc?65n(5I<)CW|S;Y5@K_v@joKO5)n_+#l*W2bxWMZ=~%5yjKxW*@?Jo$%}fcSa-1 zzv$ccj=gPFc}2>=s{l0s*+;~)0MJ`r04M^K0P+AifHi2-hG){(})A_GogOdCda%+@o*#b9q>kZ>US0CpAr* zp%>Fto1u@>f3q3dnf}e@iHw$*qyGUFq{*Dy%Qi!=rmHqXZ>FpEvrxax%~Q3UENcOm K20VOA%JB!&?Mhq# diff --git a/src/blokus_gym/core/__init__.py b/src/blokus_gym/core/__init__.py index 06513ef..745a10d 100644 --- a/src/blokus_gym/core/__init__.py +++ b/src/blokus_gym/core/__init__.py @@ -1,15 +1,32 @@ -from blokus_gym.core.board import Board -from blokus_gym.core.bots import Bot, GreedyBot, GreedyCornersBot, MinimaxBot, RandomBot -from blokus_gym.core.game import BlokusGame, Move -from blokus_gym.core.pieces import ( - DUO_PIECES, - JUNIOR_PIECES, - STANDARD_PIECES, - Piece, - PieceOrientation, - PieceSet, - generate_orientations, -) +# Try to import Cython version first, fall back to Python +try: + from .blokus_cython import ( + Board, + BlokusGame, + Move, + Piece, + PieceOrientation, + PieceSet, + ) + # Import STANDARD_PIECES from pieces.py since it's not in Cython + from .pieces import STANDARD_PIECES, DUO_PIECES, JUNIOR_PIECES + # Import generate_orientations from pieces.py + from .pieces import generate_orientations + # Import bots from Python since they're not in Cython + from .bots import Bot, GreedyBot, GreedyCornersBot, MinimaxBot, RandomBot +except ImportError: + from .board import Board + from .bots import Bot, GreedyBot, GreedyCornersBot, MinimaxBot, RandomBot + from .game import BlokusGame, Move + from .pieces import ( + DUO_PIECES, + JUNIOR_PIECES, + STANDARD_PIECES, + Piece, + PieceOrientation, + PieceSet, + generate_orientations, + ) __all__ = [ "Board", diff --git a/src/blokus_gym/core/__pycache__/__init__.cpython-311.pyc b/src/blokus_gym/core/__pycache__/__init__.cpython-311.pyc deleted file mode 100644 index 926d38dc1ef7cd2ccb24fed12258be41f6c03279..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 889 zcmcJMzi!(w5XMRUv1Hk@6G zfCM}wA#am5-yu5~%}`=rWAY@aO;F_ggli+L?7oO)64}b^i&E8(BxA_}!f+EF2$?fk zz>0U0<|&UqR0qd#o(QhP$WUHC6PH)TQOudLPQ*JFIm#QHjp*s|;lbfV`LEB0$D{E! z4JL2)hlBm`V7p+SrfkYoSbat^WqBEwsmPUEtxQ;{c4thN5todLyZs^xq^WJlIslq1 zTYvx%0(?LN&;+yr7QhAAfEvKj7)BkndtN!Avjy)?g=F1x=uUNs>O9^ni;dcSp-TMm z@tJPVU8U;jL%BILq4=ZPs`v+nz=3iojkAo>Z|Fv+=ytF7UdYR09#2_squMLv^mhne zdf=r;ss4W@rQP}B)_uuEa+R@H^0`*P`Ypa|tWAvZ3cXm~pDXls`EPTD_LhH}Ys1CH U8vPG+!iHAf;*$f9e5TF(0zAp=MgRZ+ diff --git a/src/blokus_gym/core/__pycache__/__init__.cpython-312.pyc b/src/blokus_gym/core/__pycache__/__init__.cpython-312.pyc index bbbfec9e5d5f3bd3ab70502ada2c6d674ace3958..8b936743fa2032a142c3cd54ea54e40a0f9b587c 100644 GIT binary patch literal 946 zcmaKqy>AmS7>DgU-)DMF+ENw@3kc~z^n?%#LP$wdRY6KpwREVL(=}(MDd#xyU1>9b z1T#B38$0{~Obkp6EEcE(LWnJDhoDZ_PODOedU)>V*YB78-sd3jfn4vOzu5VN0QjLc zr%UejI{GF*Z-56`@>4+Ga{y3751+ z*%S?MK&SCEE#oq+;0m3=GZ1t^>b`||e&}5XWcCK&ceTHj&8d19$I7~PcImVy?d!;z zCq3wX{^@hl%O-gJU=Qq@n_v%y{%uVw7%ZoZOGB2be(Bf?tkkq!|R z{b}En(JJA-ok%NIF!qGLcJ+OaEM1{ARD;qshK@Tub^Xqf&;Do9Y?{SCiwG z(hgVi@iT71=bS$f@(j}onNT=6*Uj9RZ7N7=g;UWaOV!e q6tusig#&$bfNqWrS4B!3DU3XMew?dUeYJQWe7IM=ZGOB3CI12hMCcs= literal 745 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 diff --git a/src/blokus_gym/core/__pycache__/board.cpython-312.pyc b/src/blokus_gym/core/__pycache__/board.cpython-312.pyc index fad1e88c2b14cbc47ad6dceb4e23601fd5a78720..52125f42ed410145fde6e6aa1bd7f145d6ab02a0 100644 GIT binary patch delta 1015 zcmYjPT}TvB6ux)<)R~C0`ZVCC| zLnU@Avln};EFui*DS8Zon8Ak?iRjh0Q0b+}&fQhoU(wgz(0L*{Po6Wki`0`&=YITvI}y3aA3Q$v)x+)JQqe01L@}QV6J% z3Zesgh(SDnMM>GLTq?%T^7-x}H5N)%I}G4tI&0 zxRCU&2XOO2G#O{SS`GHeJ~lf28M17T4Z3D zjIVOZ#40zQuu51=DToAX+n`%=YuyFVCecqNU@KKC73PcR{B7H{@4H?!=bQCCtzIza zO}i%Iltq^Hqx7#Hs!WKG@yUoDkYX@|-6MepSH~L<=^Mqswe*{EK!ypz`cin2qw7j1 z&rP(_8M&GcxymXmm?koLO9fcv6Y){2i4k1xA`SG3>)6>AU=k-mWE*@Q%2Y)h_>{=^ z@X?RnOmmOZ+++6++9dAu#_h{v%gy7<;pB8%#$`Az!>$ZEuBH{OD5F(5T9sWLaiyT4b&7=#0umaaqU- zHW^d2Ld@Aj`?WIMK$F^dZ4`*aBM_5l(~Zo!MR7WB#b2KBH#+`CI~e^Ob%O17$GK(y z`K6-5Te#F@6>331wd{%;84;uldMoawKlIabb{`*%Xh5Q2&lh}l>7S_FaJer=;%09-Dc3cC&EzZX)9vKupNP zBcn#j=)N%$&qbaB))cZ%sMlZmUSgZI!qn%pl+Aom?7$mtK|Deq`|j!k7zV)n delta 878 zcmYjPO-vI(6rP#gEw%gCKU&&SZNLQ9fNg1&s03(2LaY&p5;X=ccJY_f79*IhlE?v- zNSZkaCMt<1tp}5uaPv&`!lsEuqR~W+;bMr@v%cN7$Yk?WFHJg#=^}(H3;DT`lw*!PFQ`G42Nr<^U`Y+BBCxDBs}itN4XZM+OWmtF zf!*pp)dlRCaVwFcA3w5_455FVL$`DIT024oTs>k8j?#(FOf^(}gmO%dsQ4u*FjZv$ zEwYPThPi|?WITkBmBH%V)SjITwq9+Q#?`fpBu^H?EXpuCr?aPJD1&Rx4WuyiiKC6a zbto-1O@e}&7hsdjWH-rlR`Z#PA0TT3pzVBb=mZ$E=$p&)uqofPwEwBHtgPHLg7K28 zi%z(cLWP5X)krF2ga1u2UVM-K;3K$=+JzQUz%(fw$C%y{`hyCii4eQVWGAMy7+4Ca zU4ecQ`i75yl1%~3qAz^o(r7sxH{j#rAERBblI29&NTk<}mJ(-5(X;adWg%h+k(Hn! zbZp3;vfOIOtt)9mj;`CInhUDXb>4@6(g$L^x!xI_$uR?HeDr@$RZPE%S1_R`rDK?( zcctxqg;mJbUs&2<>xx_E;A*x-TDPTJR0Z?(D4dos17q}!9K>GwL7r~u10j1KU>5zB zkkV1$<{LHw;c_5m1Y)m(r9e+H=e&;n@H~)q004?uGdXAqQEGSh;$b@IKE-KqQ0O!F z8Xhf9deRu5E3SGwF&?Ae8@KTV`ra4!4M98YW@4vV$z}~!>!i*86mKflSi!&S@95s; zn>!;rS!^w9M;!)BsjKv}|Fz8=oR*}^O&VXZGu$AqI9M)5eStf!ag5XW7qZBj!9SkQ B!ixX^ diff --git a/src/blokus_gym/core/__pycache__/bots.cpython-311.pyc b/src/blokus_gym/core/__pycache__/bots.cpython-311.pyc deleted file mode 100644 index 373209f654eee7e21e9e7f7161a076857616f197..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 9326 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 diff --git a/src/blokus_gym/core/__pycache__/game.cpython-311.pyc b/src/blokus_gym/core/__pycache__/game.cpython-311.pyc deleted file mode 100644 index 855d204a84d181fd6597038d75c6cfb17e1c6a14..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 22665 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 delta 77 zcmcb&lJU+;M&8rByj%=GU}{sFwQM8rH@V4t2ArFDurTdO`hty>$m(6{80crsGU>ec@ diff --git a/src/blokus_gym/core/__pycache__/pieces.cpython-311.pyc b/src/blokus_gym/core/__pycache__/pieces.cpython-311.pyc deleted file mode 100644 index de8f7372ef1c626a9bf144006c880cb26b930afa..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 15764 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 diff --git a/src/blokus_gym/core/blokus_cython.c b/src/blokus_gym/core/blokus_cython.c new file mode 100644 index 0000000..f8f6265 --- /dev/null +++ b/src/blokus_gym/core/blokus_cython.c @@ -0,0 +1,61414 @@ +/* Generated by Cython 3.2.9 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "define_macros": [ + [ + "NPY_NO_DEPRECATED_API", + "NPY_1_7_API_VERSION" + ] + ], + "depends": [ + "/home/matt/miniconda3/lib/python3.12/site-packages/numpy/_core/include/numpy/arrayobject.h", + "/home/matt/miniconda3/lib/python3.12/site-packages/numpy/_core/include/numpy/arrayscalars.h", + "/home/matt/miniconda3/lib/python3.12/site-packages/numpy/_core/include/numpy/ndarrayobject.h", + "/home/matt/miniconda3/lib/python3.12/site-packages/numpy/_core/include/numpy/ndarraytypes.h", + "/home/matt/miniconda3/lib/python3.12/site-packages/numpy/_core/include/numpy/ufuncobject.h" + ], + "include_dirs": [ + "/home/matt/miniconda3/lib/python3.12/site-packages/numpy/_core/include" + ], + "name": "blokus_gym.core.blokus_cython", + "sources": [ + "blokus_gym/core/blokus_cython.pyx" + ] + }, + "module_name": "blokus_gym.core.blokus_cython" +} +END: Cython Metadata */ + +#ifndef PY_SSIZE_T_CLEAN +#define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ +/* InitLimitedAPI */ +#if defined(Py_LIMITED_API) + #if !defined(CYTHON_LIMITED_API) + #define CYTHON_LIMITED_API 1 + #endif +#elif defined(CYTHON_LIMITED_API) + #ifdef _MSC_VER + #pragma message ("Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead.") + #else + #warning Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead. + #endif +#endif + +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x03080000 + #error Cython requires Python 3.8+. +#else +#define __PYX_ABI_VERSION "3_2_9" +#define CYTHON_HEX_VERSION 0x030209F0 +#define CYTHON_FUTURE_DIVISION 1 +/* CModulePreamble */ +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#define __PYX_COMMA , +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX +#if defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #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_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 1 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #undef CYTHON_IMMORTAL_CONSTANTS + #define CYTHON_IMMORTAL_CONSTANTS 0 +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #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_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #ifndef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 1 + #endif + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PYPY_VERSION_NUM >= 0x07030C00) + #endif + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_NUM >= 0x07031100) + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #undef CYTHON_IMMORTAL_CONSTANTS + #define CYTHON_IMMORTAL_CONSTANTS 0 +#elif defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API + #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #endif + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 + #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND (__PYX_LIMITED_VERSION_HEX >= 0x030A0000) + #endif + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 1 + #endif + #undef CYTHON_IMMORTAL_CONSTANTS + #define CYTHON_IMMORTAL_CONSTANTS 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #ifdef Py_GIL_DISABLED + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 1 + #else + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #endif + #if PY_VERSION_HEX < 0x030A0000 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #elif !defined(CYTHON_USE_TYPE_SLOTS) + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLIST_INTERNALS) + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING || 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 + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #elif !defined(CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS) + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #elif !defined(CYTHON_FAST_GIL) + #define CYTHON_FAST_GIL (PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #ifndef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING (PY_VERSION_HEX >= 0x030d00B1) + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5 && !CYTHON_USE_MODULE_STATE) + #endif + #ifndef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 1 + #endif + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS (!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) + #endif + #if defined(CYTHON_IMMORTAL_CONSTANTS) && PY_VERSION_HEX < 0x030C0000 + #undef CYTHON_IMMORTAL_CONSTANTS + #define CYTHON_IMMORTAL_CONSTANTS 0 // definitely won't work + #elif !defined(CYTHON_IMMORTAL_CONSTANTS) + #define CYTHON_IMMORTAL_CONSTANTS (PY_VERSION_HEX >= 0x030C0000 && !CYTHON_USE_MODULE_STATE && CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) + #endif +#endif +#ifndef CYTHON_COMPRESS_STRINGS + #define CYTHON_COMPRESS_STRINGS 1 +#endif +#ifndef CYTHON_FAST_PYCCALL +#define CYTHON_FAST_PYCCALL CYTHON_FAST_PYCALL +#endif +#ifndef CYTHON_VECTORCALL +#if CYTHON_COMPILING_IN_LIMITED_API +#define CYTHON_VECTORCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) +#else +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL) +#endif +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #undef SHIFT + #undef BASE + #undef MASK + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + #endif +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_USE_CPP_STD_MOVE + #if defined(__cplusplus) && (\ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) +#include +typedef uintptr_t __pyx_uintptr_t; +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + #if defined(__clang__) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif +#ifndef Py_UNREACHABLE + #define Py_UNREACHABLE() assert(0); abort() +#endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX < 0x03090000) +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) + +/* CInitCode */ +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #elif defined(__GNUC__) + #define CYTHON_INLINE __inline__ + #elif defined(_MSC_VER) + #define CYTHON_INLINE __inline + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_INLINE inline + #else + #define CYTHON_INLINE + #endif +#endif + +/* PythonCompatibility */ +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#define __Pyx_BUILTIN_MODULE_NAME "builtins" +#define __Pyx_DefaultClassType PyType_Type +#if CYTHON_COMPILING_IN_LIMITED_API + #ifndef CO_OPTIMIZED + static int CO_OPTIMIZED; + #endif + #ifndef CO_NEWLOCALS + static int CO_NEWLOCALS; + #endif + #ifndef CO_VARARGS + static int CO_VARARGS; + #endif + #ifndef CO_VARKEYWORDS + static int CO_VARKEYWORDS; + #endif + #ifndef CO_ASYNC_GENERATOR + static int CO_ASYNC_GENERATOR; + #endif + #ifndef CO_GENERATOR + static int CO_GENERATOR; + #endif + #ifndef CO_COROUTINE + static int CO_COROUTINE; + #endif +#else + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 + #endif +#endif +static int __Pyx_init_co_variables(void); +#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif +#ifndef Py_TPFLAGS_IMMUTABLETYPE + #define Py_TPFLAGS_IMMUTABLETYPE (1UL << 8) +#endif +#ifndef Py_TPFLAGS_DISALLOW_INSTANTIATION + #define Py_TPFLAGS_DISALLOW_INSTANTIATION (1UL << 7) +#endif +#ifndef METH_STACKLESS + #define METH_STACKLESS 0 +#endif +#ifndef 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 + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif +#endif +#if CYTHON_METH_FASTCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#if PY_VERSION_HEX >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#endif +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} +#endif +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void (*cfunc)(void)) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; +#else + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +#endif +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if PY_VERSION_HEX < 0x03090000 || (CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000) + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); +#else + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) +#elif CYTHON_COMPILING_IN_GRAAL && defined(GRAALPY_VERSION_NUM) && GRAALPY_VERSION_NUM > 0x19000000 + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) GraalPyFrame_SetLineNumber((frame), (lineno)) +#elif CYTHON_COMPILING_IN_GRAAL + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #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_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#endif +#if CYTHON_USE_MODULE_STATE +static CYTHON_INLINE void *__Pyx__PyModule_GetState(PyObject *op) +{ + void *result; + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; +} +#define __Pyx_PyModule_GetState(o) (__pyx_mstatetype *)__Pyx__PyModule_GetState(o) +#else +#define __Pyx_PyModule_GetState(op) ((void)op,__pyx_mstate_global) +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE((PyObject *) obj), name, func_ctype) +#define __Pyx_PyObject_TryGetSlot(obj, name, func_ctype) __Pyx_PyType_TryGetSlot(Py_TYPE(obj), name, func_ctype) +#define __Pyx_PyObject_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(Py_TYPE(obj), sub, name, func_ctype) +#define __Pyx_PyObject_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSubSlot(Py_TYPE(obj), sub, name, func_ctype) +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) + #define __Pyx_PyType_TryGetSlot(type, name, func_ctype) __Pyx_PyType_GetSlot(type, name, func_ctype) + #define __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) (((type)->sub) ? ((type)->sub->name) : NULL) + #define __Pyx_PyType_TryGetSubSlot(type, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) + #define __Pyx_PyType_TryGetSlot(type, name, func_ctype)\ + ((__PYX_LIMITED_VERSION_HEX >= 0x030A0000 ||\ + (PyType_GetFlags(type) & Py_TPFLAGS_HEAPTYPE) || __Pyx_get_runtime_version() >= 0x030A0000) ?\ + __Pyx_PyType_GetSlot(type, name, func_ctype) : NULL) + #define __Pyx_PyType_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSlot(obj, name, func_ctype) + #define __Pyx_PyType_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSlot(obj, name, func_ctype) +#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 +#define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) +#define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL) PyErr_Clear(); + return res; +} +#elif !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000 +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) +#endif +#define __Pyx_PyObject_GetIterNextFunc(iterator) __Pyx_PyObject_GetSlot(iterator, tp_iternext, iternextfunc) +#if CYTHON_USE_TYPE_SPECS +#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ + PyTypeObject *type = Py_TYPE((PyObject*)obj);\ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ + PyObject_GC_Del(obj);\ + Py_DECREF(type);\ +} +#else +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#else + #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_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, (Py_UCS4) ch) + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #else + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif + #endif +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif +#endif +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && PyUnstable_Object_IsUniquelyReferenced(obj)) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#elif CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#else + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) +#endif +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +enum __Pyx_ReferenceSharing { + __Pyx_ReferenceSharing_DefinitelyUnique, // We created it so we know it's unshared - no need to check + __Pyx_ReferenceSharing_OwnStrongReference, + __Pyx_ReferenceSharing_FunctionArgument, + __Pyx_ReferenceSharing_SharedReference, // Never trust it to be unshared because it's a global or similar +}; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && PY_VERSION_HEX >= 0x030E0000 +#define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing)\ + (sharing == __Pyx_ReferenceSharing_DefinitelyUnique ? 1 :\ + (sharing == __Pyx_ReferenceSharing_FunctionArgument ? PyUnstable_Object_IsUniqueReferencedTemporary(o) :\ + (sharing == __Pyx_ReferenceSharing_OwnStrongReference ? PyUnstable_Object_IsUniquelyReferenced(o) : 0))) +#elif (CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing) (((void)sharing), Py_REFCNT(o) == 1) +#else +#define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing) (((void)o), ((void)sharing), 0) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #if CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyList_GetItemRef(o, i) (likely((i) >= 0) ? PySequence_GetItem(o, i) : (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) + #else + #define __Pyx_PyList_GetItemRef(o, i) PySequence_ITEM(o, i) + #endif +#elif CYTHON_COMPILING_IN_LIMITED_API || !(CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE) + #define __Pyx_PyList_GetItemRef(o, i) __Pyx_XNewRef(PyList_GetItem(o, i)) +#else + #define __Pyx_PyList_GetItemRef(o, i) (likely(__Pyx_is_valid_index(i, PyList_GET_SIZE(o))) ?\ + __Pyx_NewRef(PyList_GET_ITEM(o, i)) : (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +#endif +#if CYTHON_AVOID_BORROWED_REFS || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared) ((void)(unsafe_shared),\ + __Pyx_PyList_GetItemRef(o, i)) +#elif CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared) (\ + __Pyx_IS_UNIQUELY_REFERENCED(o, unsafe_shared) ?\ + __Pyx_NewRef(PyList_GET_ITEM(o, i)) : __Pyx_PyList_GetItemRef(o, i)) + #else + #define __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared) (\ + __Pyx_IS_UNIQUELY_REFERENCED(o, unsafe_shared) ?\ + __Pyx_XNewRef(PyList_GetItem(o, i)) : __Pyx_PyList_GetItemRef(o, i)) + #endif +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared) ((void)(unsafe_shared),\ + __Pyx_NewRef(PyList_GET_ITEM(o, i))) +#else + #define __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared) ((void)(unsafe_shared),\ + __Pyx_XNewRef(PyList_GetItem(o, i))) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_PyDict_GetItemRef(dict, key, result) PyDict_GetItemRef(dict, key, result) +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS +static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { + *result = PyObject_GetItem(dict, key); + if (*result == NULL) { + if (PyErr_ExceptionMatches(PyExc_KeyError)) { + PyErr_Clear(); + return 0; + } + return -1; + } + return 1; +} +#else +static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { + *result = PyDict_GetItemWithError(dict, key); + if (*result == NULL) { + return PyErr_Occurred() ? -1 : 0; + } + Py_INCREF(*result); + return 1; +} +#endif +#if defined(CYTHON_DEBUG_VISIT_CONST) && CYTHON_DEBUG_VISIT_CONST + #define __Pyx_VISIT_CONST(obj) Py_VISIT(obj) +#else + #define __Pyx_VISIT_CONST(obj) +#endif +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) + #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GET_ITEM(o, i) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_GET_ITEM(o, i) PyList_GET_ITEM(o, i) +#else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GetItem(o, i) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyList_GET_ITEM(o, i) PyList_GetItem(o, i) +#endif +#if CYTHON_ASSUME_SAFE_SIZE + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GET_LENGTH(o) +#else + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GetLength(o) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_InternFromString) + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) +#endif +#define __Pyx_PyLong_FromHash_t PyLong_FromSsize_t +#define __Pyx_PyLong_AsHash_t __Pyx_PyIndex_AsSsize_t +#if __PYX_LIMITED_VERSION_HEX >= 0x030A0000 + #define __Pyx_PySendResult PySendResult +#else + typedef enum { + PYGEN_RETURN = 0, + PYGEN_ERROR = -1, + PYGEN_NEXT = 1, + } __Pyx_PySendResult; +#endif +#if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030A00A3 + typedef __Pyx_PySendResult (*__Pyx_pyiter_sendfunc)(PyObject *iter, PyObject *value, PyObject **result); +#else + #define __Pyx_pyiter_sendfunc sendfunc +#endif +#if !CYTHON_USE_AM_SEND +#define __PYX_HAS_PY_AM_SEND 0 +#elif __PYX_LIMITED_VERSION_HEX >= 0x030A0000 +#define __PYX_HAS_PY_AM_SEND 1 +#else +#define __PYX_HAS_PY_AM_SEND 2 // our own backported implementation +#endif +#if __PYX_HAS_PY_AM_SEND < 2 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#else + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + __Pyx_pyiter_sendfunc am_send; + } __Pyx_PyAsyncMethodsStruct; + #define __Pyx_SlotTpAsAsync(s) ((PyAsyncMethods*)(s)) +#endif +#if CYTHON_USE_AM_SEND && PY_VERSION_HEX < 0x030A00F0 + #define __Pyx_TPFLAGS_HAVE_AM_SEND (1UL << 21) +#else + #define __Pyx_TPFLAGS_HAVE_AM_SEND (0) +#endif +#if PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyInterpreterState_Get() PyInterpreterState_Get() +#else +#define __Pyx_PyInterpreterState_Get() PyThreadState_Get()->interp +#endif +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030A0000 +#ifdef __cplusplus +extern "C" +#endif +PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize); +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_init_co_variable(PyObject *inspect, const char* name, int *write_to) { + int value; + PyObject *py_value = PyObject_GetAttrString(inspect, name); + if (!py_value) return 0; + value = (int) PyLong_AsLong(py_value); + Py_DECREF(py_value); + *write_to = value; + return value != -1 || !PyErr_Occurred(); +} +static int __Pyx_init_co_variables(void) { + PyObject *inspect; + int result; + inspect = PyImport_ImportModule("inspect"); + result = +#if !defined(CO_OPTIMIZED) + __Pyx_init_co_variable(inspect, "CO_OPTIMIZED", &CO_OPTIMIZED) && +#endif +#if !defined(CO_NEWLOCALS) + __Pyx_init_co_variable(inspect, "CO_NEWLOCALS", &CO_NEWLOCALS) && +#endif +#if !defined(CO_VARARGS) + __Pyx_init_co_variable(inspect, "CO_VARARGS", &CO_VARARGS) && +#endif +#if !defined(CO_VARKEYWORDS) + __Pyx_init_co_variable(inspect, "CO_VARKEYWORDS", &CO_VARKEYWORDS) && +#endif +#if !defined(CO_ASYNC_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_ASYNC_GENERATOR", &CO_ASYNC_GENERATOR) && +#endif +#if !defined(CO_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_GENERATOR", &CO_GENERATOR) && +#endif +#if !defined(CO_COROUTINE) + __Pyx_init_co_variable(inspect, "CO_COROUTINE", &CO_COROUTINE) && +#endif + 1; + Py_DECREF(inspect); + return result ? 0 : -1; +} +#else +static int __Pyx_init_co_variables(void) { + return 0; // It's a limited API-only feature +} +#endif + +/* MathInitCode */ +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #ifndef _USE_MATH_DEFINES + #define _USE_MATH_DEFINES + #endif +#endif +#include +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + +#ifndef CYTHON_CLINE_IN_TRACEBACK_RUNTIME +#define CYTHON_CLINE_IN_TRACEBACK_RUNTIME 0 +#endif +#ifndef CYTHON_CLINE_IN_TRACEBACK +#define CYTHON_CLINE_IN_TRACEBACK CYTHON_CLINE_IN_TRACEBACK_RUNTIME +#endif +#if CYTHON_CLINE_IN_TRACEBACK +#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; } +#else +#define __PYX_MARK_ERR_POS(f_index, lineno) { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; (void) __pyx_clineno; } +#endif +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifdef CYTHON_EXTERN_C + #undef __PYX_EXTERN_C + #define __PYX_EXTERN_C CYTHON_EXTERN_C +#elif defined(__PYX_EXTERN_C) + #ifdef _MSC_VER + #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") + #else + #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. + #endif +#else + #ifdef __cplusplus + #define __PYX_EXTERN_C extern "C" + #else + #define __PYX_EXTERN_C extern + #endif +#endif + +#define __PYX_HAVE__blokus_gym__core__blokus_cython +#define __PYX_HAVE_API__blokus_gym__core__blokus_cython +/* Early includes */ +#include +#include + + /* Using NumPy API declarations from "numpy/__init__.cython-30.pxd" */ + +#include "numpy/arrayobject.h" +#include "numpy/ndarrayobject.h" +#include "numpy/ndarraytypes.h" +#include "numpy/arrayscalars.h" +#include "numpy/ufuncobject.h" +#include "pythread.h" +#include +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +#ifdef CYTHON_FREETHREADING_COMPATIBLE +#if CYTHON_FREETHREADING_COMPATIBLE +#define __Pyx_FREETHREADING_COMPATIBLE Py_MOD_GIL_NOT_USED +#else +#define __Pyx_FREETHREADING_COMPATIBLE Py_MOD_GIL_USED +#endif +#else +#define __Pyx_FREETHREADING_COMPATIBLE Py_MOD_GIL_USED +#endif +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 +#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 Py_ssize_t __Pyx_ssize_strlen(const char *s); +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if CYTHON_ASSUME_SAFE_MACROS + #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_PyByteArray_AsString(s) PyByteArray_AS_STRING(s) +#else + #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AsString(s)) + #define __Pyx_PyByteArray_AsString(s) PyByteArray_AsString(s) +#endif +#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +static CYTHON_INLINE PyObject *__Pyx_NewRef(PyObject *obj) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_NewRef) + return Py_NewRef(obj); +#else + Py_INCREF(obj); + return obj; +#endif +} +static CYTHON_INLINE PyObject *__Pyx_XNewRef(PyObject *obj) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_XNewRef) + return Py_XNewRef(obj); +#else + Py_XINCREF(obj); + return obj; +#endif +} +static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b); +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_Long(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_PyLong_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)) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AS_DOUBLE(x) +#else +#define __Pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AsDouble(x) +#endif +#define __Pyx_PyFloat_AsFloat(x) ((float) __Pyx_PyFloat_AsDouble(x)) +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#elif __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeASCII(c_str, size, NULL) +#else + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#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__ */ +/* PretendToInitialize */ +#ifdef __cplusplus +#if __cplusplus > 201103L +#include +#endif +template +static void __Pyx_pretend_to_initialize(T* ptr) { +#if __cplusplus > 201103L + if ((std::is_trivially_default_constructible::value)) +#endif + *ptr = T(); + (void)ptr; +} +#else +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#endif + + +#if !CYTHON_USE_MODULE_STATE +static PyObject *__pyx_m = NULL; +#endif +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * const __pyx_cfilenm = __FILE__; +static const char *__pyx_filename; + +/* Header.proto */ +#if !defined(CYTHON_CCOMPLEX) + #if defined(__cplusplus) + #define CYTHON_CCOMPLEX 1 + #elif (defined(_Complex_I) && !defined(_MSC_VER)) || ((defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) && !defined(__STDC_NO_COMPLEX__) && !defined(_MSC_VER)) + #define CYTHON_CCOMPLEX 1 + #else + #define CYTHON_CCOMPLEX 0 + #endif +#endif +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #include + #else + #include + #endif +#endif +#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) + #undef _Complex_I + #define _Complex_I 1.0fj +#endif + +/* #### Code section: filename_table ### */ + +static const char* const __pyx_f[] = { + "blokus_gym/core/blokus_cython.pyx", + "", + "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd", + "cpython/type.pxd", +}; +/* #### Code section: utility_code_proto_before_types ### */ +/* Atomics.proto (used by UnpackUnboundCMethod) */ +#include +#ifndef CYTHON_ATOMICS + #define CYTHON_ATOMICS 1 +#endif +#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS +#define __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __pyx_atomic_int_type int +#define __pyx_nonatomic_int_type int +#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ + (__STDC_VERSION__ >= 201112L) &&\ + !defined(__STDC_NO_ATOMICS__)) + #include +#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ + (__cplusplus >= 201103L) ||\ + (defined(_MSC_VER) && _MSC_VER >= 1700))) + #include +#endif +#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ + (__STDC_VERSION__ >= 201112L) &&\ + !defined(__STDC_NO_ATOMICS__) &&\ + ATOMIC_INT_LOCK_FREE == 2) + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type atomic_int + #define __pyx_atomic_ptr_type atomic_uintptr_t + #define __pyx_nonatomic_ptr_type uintptr_t + #define __pyx_atomic_incr_relaxed(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed) + #define __pyx_atomic_incr_acq_rel(value) atomic_fetch_add_explicit(value, 1, memory_order_acq_rel) + #define __pyx_atomic_decr_acq_rel(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel) + #define __pyx_atomic_sub(value, arg) atomic_fetch_sub(value, arg) + #define __pyx_atomic_int_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired) + #define __pyx_atomic_load(value) atomic_load(value) + #define __pyx_atomic_store(value, new_value) atomic_store(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) atomic_load_explicit(value, memory_order_relaxed) + #define __pyx_atomic_pointer_load_acquire(value) atomic_load_explicit(value, memory_order_acquire) + #define __pyx_atomic_pointer_exchange(value, new_value) atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) + #define __pyx_atomic_pointer_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired) + #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) + #pragma message ("Using standard C atomics") + #elif defined(__PYX_DEBUG_ATOMICS) + #warning "Using standard C atomics" + #endif +#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ + (__cplusplus >= 201103L) ||\ +\ + (defined(_MSC_VER) && _MSC_VER >= 1700)) &&\ + ATOMIC_INT_LOCK_FREE == 2) + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type std::atomic_int + #define __pyx_atomic_ptr_type std::atomic_uintptr_t + #define __pyx_nonatomic_ptr_type uintptr_t + #define __pyx_atomic_incr_relaxed(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed) + #define __pyx_atomic_incr_acq_rel(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_acq_rel) + #define __pyx_atomic_decr_acq_rel(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel) + #define __pyx_atomic_sub(value, arg) std::atomic_fetch_sub(value, arg) + #define __pyx_atomic_int_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired) + #define __pyx_atomic_load(value) std::atomic_load(value) + #define __pyx_atomic_store(value, new_value) std::atomic_store(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) std::atomic_load_explicit(value, std::memory_order_relaxed) + #define __pyx_atomic_pointer_load_acquire(value) std::atomic_load_explicit(value, std::memory_order_acquire) + #define __pyx_atomic_pointer_exchange(value, new_value) std::atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) + #define __pyx_atomic_pointer_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired) + #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) + #pragma message ("Using standard C++ atomics") + #elif defined(__PYX_DEBUG_ATOMICS) + #warning "Using standard C++ atomics" + #endif +#elif CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\ + (__GNUC_MINOR__ > 1 ||\ + (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) + #define __pyx_atomic_ptr_type void* + #define __pyx_nonatomic_ptr_type void* + #define __pyx_atomic_incr_relaxed(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_incr_acq_rel(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_decr_acq_rel(value) __sync_fetch_and_sub(value, 1) + #define __pyx_atomic_sub(value, arg) __sync_fetch_and_sub(value, arg) + static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { + __pyx_nonatomic_int_type old = __sync_val_compare_and_swap(value, *expected, desired); + int result = old == *expected; + *expected = old; + return result; + } + #define __pyx_atomic_load(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_store(value, new_value) __sync_lock_test_and_set(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_pointer_load_acquire(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_pointer_exchange(value, new_value) __sync_lock_test_and_set(value, (__pyx_atomic_ptr_type)new_value) + static CYTHON_INLINE int __pyx_atomic_pointer_cmp_exchange(__pyx_atomic_ptr_type* value, __pyx_nonatomic_ptr_type* expected, __pyx_nonatomic_ptr_type desired) { + __pyx_nonatomic_ptr_type old = __sync_val_compare_and_swap(value, *expected, desired); + int result = old == *expected; + *expected = old; + return result; + } + #ifdef __PYX_DEBUG_ATOMICS + #warning "Using GNU atomics" + #endif +#elif CYTHON_ATOMICS && defined(_MSC_VER) + #include + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type long + #define __pyx_atomic_ptr_type void* + #undef __pyx_nonatomic_int_type + #define __pyx_nonatomic_int_type long + #define __pyx_nonatomic_ptr_type void* + #pragma intrinsic (_InterlockedExchangeAdd, _InterlockedExchange, _InterlockedCompareExchange, _InterlockedCompareExchangePointer, _InterlockedExchangePointer) + #define __pyx_atomic_incr_relaxed(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_incr_acq_rel(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_decr_acq_rel(value) _InterlockedExchangeAdd(value, -1) + #define __pyx_atomic_sub(value, arg) _InterlockedExchangeAdd(value, -arg) + static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { + __pyx_nonatomic_int_type old = _InterlockedCompareExchange(value, desired, *expected); + int result = old == *expected; + *expected = old; + return result; + } + #define __pyx_atomic_load(value) _InterlockedExchangeAdd(value, 0) + #define __pyx_atomic_store(value, new_value) _InterlockedExchange(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) *(void * volatile *)value + #define __pyx_atomic_pointer_load_acquire(value) _InterlockedCompareExchangePointer(value, 0, 0) + #define __pyx_atomic_pointer_exchange(value, new_value) _InterlockedExchangePointer(value, (__pyx_atomic_ptr_type)new_value) + static CYTHON_INLINE int __pyx_atomic_pointer_cmp_exchange(__pyx_atomic_ptr_type* value, __pyx_nonatomic_ptr_type* expected, __pyx_nonatomic_ptr_type desired) { + __pyx_atomic_ptr_type old = _InterlockedCompareExchangePointer(value, desired, *expected); + int result = old == *expected; + *expected = old; + return result; + } + #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 + +/* CriticalSectionsDefinition.proto (used by CriticalSections) */ +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __Pyx_PyCriticalSection void* +#define __Pyx_PyCriticalSection2 void* +#define __Pyx_PyCriticalSection_End(cs) +#define __Pyx_PyCriticalSection2_End(cs) +#else +#define __Pyx_PyCriticalSection PyCriticalSection +#define __Pyx_PyCriticalSection2 PyCriticalSection2 +#define __Pyx_PyCriticalSection_End PyCriticalSection_End +#define __Pyx_PyCriticalSection2_End PyCriticalSection2_End +#endif + +/* CriticalSections.proto (used by ParseKeywordsImpl) */ +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __Pyx_PyCriticalSection_Begin(cs, arg) (void)(cs) +#define __Pyx_PyCriticalSection2_Begin(cs, arg1, arg2) (void)(cs) +#else +#define __Pyx_PyCriticalSection_Begin PyCriticalSection_Begin +#define __Pyx_PyCriticalSection2_Begin PyCriticalSection2_Begin +#endif +#if PY_VERSION_HEX < 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_BEGIN_CRITICAL_SECTION(o) { +#define __Pyx_END_CRITICAL_SECTION() } +#else +#define __Pyx_BEGIN_CRITICAL_SECTION Py_BEGIN_CRITICAL_SECTION +#define __Pyx_END_CRITICAL_SECTION Py_END_CRITICAL_SECTION +#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() + +/* IncludeStructmemberH.proto (used by FixUpExtensionType) */ +#include + +/* BufferFormatStructs.proto */ +struct __Pyx_StructField_; +#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) +typedef struct { + const char* name; + const 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_ { + const __Pyx_TypeInfo* type; + const char* name; + size_t offset; +} __Pyx_StructField; +typedef struct { + const __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; + +/* 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]) +#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 +#define __Pyx_MEMSLICE_INIT { 0, 0, { 0 }, { 0 }, { 0 } } +#if CYTHON_ATOMICS + #define __pyx_add_acquisition_count(memview)\ + __pyx_atomic_incr_relaxed(__pyx_get_slice_count_pointer(memview)) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_atomic_decr_acq_rel(__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 + +/* #### Code section: numeric_typedefs ### */ + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":743 + * # in Cython to enable them only on the right systems. + * + * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t +*/ +typedef npy_int8 __pyx_t_5numpy_int8_t; + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":744 + * + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t +*/ +typedef npy_int16 __pyx_t_5numpy_int16_t; + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":745 + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< + * ctypedef npy_int64 int64_t + * +*/ +typedef npy_int32 __pyx_t_5numpy_int32_t; + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":746 + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< + * + * ctypedef npy_uint8 uint8_t +*/ +typedef npy_int64 __pyx_t_5numpy_int64_t; + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":748 + * ctypedef npy_int64 int64_t + * + * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t +*/ +typedef npy_uint8 __pyx_t_5numpy_uint8_t; + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":749 + * + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t +*/ +typedef npy_uint16 __pyx_t_5numpy_uint16_t; + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":750 + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< + * ctypedef npy_uint64 uint64_t + * +*/ +typedef npy_uint32 __pyx_t_5numpy_uint32_t; + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":751 + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< + * + * ctypedef npy_float32 float32_t +*/ +typedef npy_uint64 __pyx_t_5numpy_uint64_t; + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":753 + * ctypedef npy_uint64 uint64_t + * + * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< + * ctypedef npy_float64 float64_t + * #ctypedef npy_float80 float80_t +*/ +typedef npy_float32 __pyx_t_5numpy_float32_t; + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":754 + * + * ctypedef npy_float32 float32_t + * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< + * #ctypedef npy_float80 float80_t + * #ctypedef npy_float128 float128_t +*/ +typedef npy_float64 __pyx_t_5numpy_float64_t; + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":761 + * ctypedef double complex complex128_t + * + * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulonglong_t + * +*/ +typedef npy_longlong __pyx_t_5numpy_longlong_t; + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":762 + * + * ctypedef npy_longlong longlong_t + * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_intp intp_t +*/ +typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":764 + * ctypedef npy_ulonglong ulonglong_t + * + * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< + * ctypedef npy_uintp uintp_t + * +*/ +typedef npy_intp __pyx_t_5numpy_intp_t; + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":765 + * + * ctypedef npy_intp intp_t + * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< + * + * ctypedef npy_double float_t +*/ +typedef npy_uintp __pyx_t_5numpy_uintp_t; + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":767 + * ctypedef npy_uintp uintp_t + * + * ctypedef npy_double float_t # <<<<<<<<<<<<<< + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t +*/ +typedef npy_double __pyx_t_5numpy_float_t; + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":768 + * + * ctypedef npy_double float_t + * ctypedef npy_double double_t # <<<<<<<<<<<<<< + * ctypedef npy_longdouble longdouble_t + * +*/ +typedef npy_double __pyx_t_5numpy_double_t; + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":769 + * ctypedef npy_double float_t + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< + * + * ctypedef float complex cfloat_t +*/ +typedef npy_longdouble __pyx_t_5numpy_longdouble_t; +/* #### Code section: complex_type_declarations ### */ +/* Declarations.proto */ +#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #ifdef __cplusplus + typedef ::std::complex< float > __pyx_t_float_complex; + #else + typedef float _Complex __pyx_t_float_complex; + #endif +#else + typedef struct { float real, imag; } __pyx_t_float_complex; +#endif +static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); + +/* Declarations.proto */ +#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #ifdef __cplusplus + typedef ::std::complex< double > __pyx_t_double_complex; + #else + typedef double _Complex __pyx_t_double_complex; + #endif +#else + typedef struct { double real, imag; } __pyx_t_double_complex; +#endif +static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); + +/* Declarations.proto */ +#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #ifdef __cplusplus + typedef ::std::complex< long double > __pyx_t_long_double_complex; + #else + typedef long double _Complex __pyx_t_long_double_complex; + #endif +#else + typedef struct { long double real, imag; } __pyx_t_long_double_complex; +#endif +static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_from_parts(long double, long double); + +/* #### Code section: type_declarations ### */ + +/*--- Type declarations ---*/ +struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board; +struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move; +struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation; +struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece; +struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet; +struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState; +struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame; +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr; +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr; +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr; +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr; +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr; +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr; +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr; +struct __pyx_array_obj; +struct __pyx_MemviewEnum_obj; +struct __pyx_memoryview_obj; +struct __pyx_memoryviewslice_obj; + +/* "blokus_gym/core/blokus_cython.pyx":17 + * # ------------------------------------------------------------------- + * + * cdef class Board: # <<<<<<<<<<<<<< + * """Cython-optimized Board class with static typing. + * +*/ +struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board { + PyObject_HEAD + struct __pyx_vtabstruct_10blokus_gym_4core_13blokus_cython_Board *__pyx_vtab; + int size; + __Pyx_memviewslice grid; + PyObject *_occupied_cache; +}; + + +/* "blokus_gym/core/blokus_cython.pyx":171 + * # ------------------------------------------------------------------- + * + * cdef class Move: # <<<<<<<<<<<<<< + * """A move in the game (piece, orientation, position).""" + * +*/ +struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move { + PyObject_HEAD + int piece_id; + int orientation_id; + int x; + int y; +}; + + +/* "blokus_gym/core/blokus_cython.pyx":189 + * + * + * cdef class PieceOrientation: # <<<<<<<<<<<<<< + * """A piece in a specific orientation (before placement on board).""" + * +*/ +struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation { + PyObject_HEAD + int piece_id; + int orientation_id; + PyObject *squares; + PyObject *corners; +}; + + +/* "blokus_gym/core/blokus_cython.pyx":204 + * + * + * cdef class Piece: # <<<<<<<<<<<<<< + * """A polyomino piece defined by a set of (x, y) coordinates.""" + * +*/ +struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece { + PyObject_HEAD + PyObject *name; + PyObject *squares; +}; + + +/* "blokus_gym/core/blokus_cython.pyx":219 + * + * + * cdef class PieceSet: # <<<<<<<<<<<<<< + * """A collection of pieces with pre-computed orientations.""" + * +*/ +struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet { + PyObject_HEAD + PyObject *pieces; + PyObject *piece_names; + PyObject *piece_id_map; + PyObject *orientations; + int num_orientations; +}; + + +/* "blokus_gym/core/blokus_cython.pyx":373 + * # ------------------------------------------------------------------- + * + * cdef class PlayerState: # <<<<<<<<<<<<<< + * """State for a single player.""" + * +*/ +struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState { + PyObject_HEAD + int idx; + PyObject *available_pieces; + PyObject *corners; + int score; + int has_started; + int can_move; +}; + + +/* "blokus_gym/core/blokus_cython.pyx":396 + * # ------------------------------------------------------------------- + * + * cdef class BlokusGame: # <<<<<<<<<<<<<< + * """Cython-optimized Blokus game engine.""" + * +*/ +struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame { + PyObject_HEAD + struct __pyx_vtabstruct_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_vtab; + int board_size; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *piece_set; + int num_players; + int corner_rule; + PyObject *board; + PyObject *players; + int current_player; + int rounds; + int game_over; + PyObject *_action_moves; + PyObject *_move_to_action; + PyObject *_actions_by_piece; + PyObject *_starting_corners; +}; + + +/* "blokus_gym/core/blokus_cython.pyx":241 + * self.orientations.append(orients) + * + * self.num_orientations = sum(len(o) for o in self.orientations) # <<<<<<<<<<<<<< + * + * @property +*/ +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr { + PyObject_HEAD + PyObject *__pyx_genexpr_arg_0; + PyObject *__pyx_v_o; + PyObject *__pyx_t_0; + Py_ssize_t __pyx_t_1; +}; + + +/* "blokus_gym/core/blokus_cython.pyx":351 + * cdef list normalize_squares_cython(list squares): + * """Normalize squares to start at (0, 0).""" + * cdef int min_x = min(x for x, _ in squares) # <<<<<<<<<<<<<< + * cdef int min_y = min(y for _, y in squares) + * +*/ +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr { + PyObject_HEAD + PyObject *__pyx_genexpr_arg_0; + PyObject *__pyx_v__; + PyObject *__pyx_v_x; + PyObject *__pyx_t_0; + Py_ssize_t __pyx_t_1; +}; + + +/* "blokus_gym/core/blokus_cython.pyx":352 + * """Normalize squares to start at (0, 0).""" + * cdef int min_x = min(x for x, _ in squares) + * cdef int min_y = min(y for _, y in squares) # <<<<<<<<<<<<<< + * + * return [(x - min_x, y - min_y) for x, y in squares] +*/ +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr { + PyObject_HEAD + PyObject *__pyx_genexpr_arg_0; + PyObject *__pyx_v__; + PyObject *__pyx_v_y; + PyObject *__pyx_t_0; + Py_ssize_t __pyx_t_1; +}; + + +/* "blokus_gym/core/blokus_cython.pyx":481 + * for orient_id, orient in enumerate(self.piece_set.get_orientations(piece_id)): + * squares = orient.squares + * max_x = max(x for x, _ in squares) # <<<<<<<<<<<<<< + * max_y = max(y for _, y in squares) + * +*/ +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr { + PyObject_HEAD + PyObject *__pyx_genexpr_arg_0; + PyObject *__pyx_v__; + PyObject *__pyx_v_x; + PyObject *__pyx_t_0; + Py_ssize_t __pyx_t_1; +}; + + +/* "blokus_gym/core/blokus_cython.pyx":482 + * squares = orient.squares + * max_x = max(x for x, _ in squares) + * max_y = max(y for _, y in squares) # <<<<<<<<<<<<<< + * + * for px in range(self.board_size - max_x): +*/ +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr { + PyObject_HEAD + PyObject *__pyx_genexpr_arg_0; + PyObject *__pyx_v__; + PyObject *__pyx_v_y; + PyObject *__pyx_t_0; + Py_ssize_t __pyx_t_1; +}; + + +/* "blokus_gym/core/blokus_cython.pyx":754 + * + * # Game ends if all players can't move + * if all(not p.can_move for p in self.players): # <<<<<<<<<<<<<< + * self.game_over = True + * elif all(p.has_started and not p.available_pieces for p in self.players): +*/ +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr { + PyObject_HEAD + PyObject *__pyx_genexpr_arg_0; + PyObject *__pyx_v_p; +}; + + +/* "blokus_gym/core/blokus_cython.pyx":756 + * if all(not p.can_move for p in self.players): + * self.game_over = True + * elif all(p.has_started and not p.available_pieces for p in self.players): # <<<<<<<<<<<<<< + * # All pieces played + * self.game_over = True +*/ +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr { + PyObject_HEAD + PyObject *__pyx_genexpr_arg_0; + PyObject *__pyx_v_p; +}; + + +/* "View.MemoryView":118 + * + * + * @cython.collection_type("sequence") # <<<<<<<<<<<<<< + * @cname("__pyx_array") + * cdef class array: +*/ +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":307 + * + * + * @cname('__pyx_MemviewEnum') # <<<<<<<<<<<<<< + * cdef class Enum(object): + * cdef object name +*/ +struct __pyx_MemviewEnum_obj { + PyObject_HEAD + PyObject *name; +}; + + +/* "View.MemoryView":342 + * + * + * @cname('__pyx_memoryview') # <<<<<<<<<<<<<< + * cdef class memoryview: + * +*/ +struct __pyx_memoryview_obj { + PyObject_HEAD + struct __pyx_vtabstruct_memoryview *__pyx_vtab; + PyObject *obj; + PyObject *_size; + void *_unused; + PyThread_type_lock lock; + __pyx_atomic_int_type acquisition_count; + Py_buffer view; + int flags; + int dtype_is_object; + __Pyx_TypeInfo const *typeinfo; +}; + + +/* "View.MemoryView":856 + * + * + * @cython.collection_type("sequence") # <<<<<<<<<<<<<< + * @cname('__pyx_memoryviewslice') + * cdef class _memoryviewslice(memoryview): +*/ +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 *); +}; + + + +/* "blokus_gym/core/blokus_cython.pyx":17 + * # ------------------------------------------------------------------- + * + * cdef class Board: # <<<<<<<<<<<<<< + * """Cython-optimized Board class with static typing. + * +*/ + +struct __pyx_vtabstruct_10blokus_gym_4core_13blokus_cython_Board { + int (*is_cell_empty)(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *, int, int); +}; +static struct __pyx_vtabstruct_10blokus_gym_4core_13blokus_cython_Board *__pyx_vtabptr_10blokus_gym_4core_13blokus_cython_Board; + + +/* "blokus_gym/core/blokus_cython.pyx":396 + * # ------------------------------------------------------------------- + * + * cdef class BlokusGame: # <<<<<<<<<<<<<< + * """Cython-optimized Blokus game engine.""" + * +*/ + +struct __pyx_vtabstruct_10blokus_gym_4core_13blokus_cython_BlokusGame { + void (*_generate_action_space)(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *); + PyObject *(*_get_placed_squares)(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *, struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *); + PyObject *(*_get_placed_corners)(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *, struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *); + int (*valid_move)(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *, int, struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *, int __pyx_skip_dispatch); + PyObject *(*get_valid_actions)(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *, int, int __pyx_skip_dispatch); + int (*has_valid_moves)(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *, int, int __pyx_skip_dispatch); +}; +static struct __pyx_vtabstruct_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_vtabptr_10blokus_gym_4core_13blokus_cython_BlokusGame; + + +/* "View.MemoryView":118 + * + * + * @cython.collection_type("sequence") # <<<<<<<<<<<<<< + * @cname("__pyx_array") + * cdef class array: +*/ + +struct __pyx_vtabstruct_array { + PyObject *(*get_memview)(struct __pyx_array_obj *); +}; +static struct __pyx_vtabstruct_array *__pyx_vtabptr_array; + + +/* "View.MemoryView":342 + * + * + * @cname('__pyx_memoryview') # <<<<<<<<<<<<<< + * cdef class memoryview: + * +*/ + +struct __pyx_vtabstruct_memoryview { + char *(*get_item_pointer)(struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*is_slice)(struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*setitem_slice_assignment)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); + PyObject *(*setitem_slice_assign_scalar)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*setitem_indexed)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); + PyObject *(*convert_item_to_object)(struct __pyx_memoryview_obj *, char *); + PyObject *(*assign_item_from_object)(struct __pyx_memoryview_obj *, char *, PyObject *); + PyObject *(*_get_base)(struct __pyx_memoryview_obj *); +}; +static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview; + + +/* "View.MemoryView":856 + * + * + * @cython.collection_type("sequence") # <<<<<<<<<<<<<< + * @cname('__pyx_memoryviewslice') + * cdef class _memoryviewslice(memoryview): +*/ + +struct __pyx_vtabstruct__memoryviewslice { + struct __pyx_vtabstruct_memoryview __pyx_base; +}; +static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice; +/* #### Code section: utility_code_proto ### */ + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_Py_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; Py_XDECREF(tmp);\ + } while (0) +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* PyErrExceptionMatches.proto (used by PyObjectGetAttrStrNoError) */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* PyThreadStateGet.proto (used by PyErrFetchRestore) */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#endif +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto (used by PyObjectGetAttrStrNoError) */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* PyObjectGetAttrStr.proto (used by PyObjectGetAttrStrNoError) */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* PyObjectGetAttrStrNoError.proto (used by GetBuiltinName) */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* TupleAndListFromArray.proto (used by fastcall) */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +#endif +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif + +/* IncludeStringH.proto (used by BytesEquals) */ +#include + +/* BytesEquals.proto (used by UnicodeEquals) */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto (used by fastcall) */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* fastcall.proto */ +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_PySequence_ITEM(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(args, i)) +#else + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_XNewRef(PyTuple_GetItem(args, i)) +#endif +#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) +#define __Pyx_KwValues_VARARGS(args, nargs) NULL +#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) +#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) +#if CYTHON_METH_FASTCALL + #define __Pyx_ArgRef_FASTCALL(args, i) __Pyx_NewRef(args[i]) + #define __Pyx_NumKwargs_FASTCALL(kwds) __Pyx_PyTuple_GET_SIZE(kwds) + #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) + static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif +#else + #define __Pyx_ArgRef_FASTCALL __Pyx_ArgRef_VARARGS + #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS +#endif +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#if CYTHON_METH_FASTCALL +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(args + start, stop - start) +#else +#define __Pyx_ArgsSlice_FASTCALL __Pyx_ArgsSlice_VARARGS +#endif + +/* py_dict_items.proto (used by OwnedDictNext) */ +static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d); + +/* CallCFunction.proto (used by CallUnboundCMethod0) */ +#define __Pyx_CallCFunction(cfunc, self, args)\ + ((PyCFunction)(void(*)(void))(cfunc)->func)(self, args) +#define __Pyx_CallCFunctionWithKeywords(cfunc, self, args, kwargs)\ + ((PyCFunctionWithKeywords)(void(*)(void))(cfunc)->func)(self, args, kwargs) +#define __Pyx_CallCFunctionFast(cfunc, self, args, nargs)\ + ((__Pyx_PyCFunctionFast)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs) +#define __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, nargs, kwnames)\ + ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs, kwnames) + +/* PyObjectCall.proto (used by PyObjectFastCall) */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* PyObjectCallMethO.proto (used by PyObjectFastCall) */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectFastCall.proto (used by PyObjectCallOneArg) */ +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs); + +/* PyObjectCallOneArg.proto (used by CallUnboundCMethod0) */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* UnpackUnboundCMethod.proto (used by CallUnboundCMethod0) */ +typedef struct { + PyObject *type; + PyObject **method_name; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && CYTHON_ATOMICS + __pyx_atomic_int_type initialized; +#endif + PyCFunction func; + PyObject *method; + int flag; +} __Pyx_CachedCFunction; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +static CYTHON_INLINE int __Pyx_CachedCFunction_GetAndSetInitializing(__Pyx_CachedCFunction *cfunc) { +#if !CYTHON_ATOMICS + return 1; +#else + __pyx_nonatomic_int_type expected = 0; + if (__pyx_atomic_int_cmp_exchange(&cfunc->initialized, &expected, 1)) { + return 0; + } + return expected; +#endif +} +static CYTHON_INLINE void __Pyx_CachedCFunction_SetFinishedInitializing(__Pyx_CachedCFunction *cfunc) { +#if CYTHON_ATOMICS + __pyx_atomic_store(&cfunc->initialized, 2); +#endif +} +#else +#define __Pyx_CachedCFunction_GetAndSetInitializing(cfunc) 2 +#define __Pyx_CachedCFunction_SetFinishedInitializing(cfunc) +#endif + +/* CallUnboundCMethod0.proto */ +CYTHON_UNUSED +static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); +#else +#define __Pyx_CallUnboundCMethod0(cfunc, self) __Pyx__CallUnboundCMethod0(cfunc, self) +#endif + +/* py_dict_values.proto (used by OwnedDictNext) */ +static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d); + +/* OwnedDictNext.proto (used by ParseKeywordsImpl) */ +#if CYTHON_AVOID_BORROWED_REFS +static int __Pyx_PyDict_NextRef(PyObject *p, PyObject **ppos, PyObject **pkey, PyObject **pvalue); +#else +CYTHON_INLINE +static int __Pyx_PyDict_NextRef(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue); +#endif + +/* RaiseDoubleKeywords.proto (used by ParseKeywordsImpl) */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywordsImpl.export */ +static int __Pyx_ParseKeywordsTuple( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs +); +static int __Pyx_ParseKeywordDictToDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name +); +static int __Pyx_ParseKeywordDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs +); + +/* CallUnboundCMethod2.proto */ +CYTHON_UNUSED +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2); +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2); +#else +#define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2) __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2) +#endif + +/* ParseKeywords.proto */ +static CYTHON_INLINE int __Pyx_ParseKeywords( + PyObject *kwds, PyObject *const *kwvalues, PyObject ** const argnames[], + PyObject *kwds2, PyObject *values[], + Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs +); + +/* 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); + +/* ArgTypeTestFunc.export */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) + +/* PyValueError_Check.proto */ +#define __Pyx_PyExc_ValueError_Check(obj) __Pyx_TypeCheck(obj, PyExc_ValueError) + +/* RaiseException.export */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* PyObjectFastCallMethod.proto */ +#if CYTHON_VECTORCALL && PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyObject_FastCallMethod(name, args, nargsf) PyObject_VectorcallMethod(name, args, nargsf, NULL) +#else +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf); +#endif + +/* RaiseUnexpectedTypeError.proto */ +static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); + +/* PyMemoryError_Check.proto */ +#define __Pyx_PyExc_MemoryError_Check(obj) __Pyx_TypeCheck(obj, PyExc_MemoryError) + +/* BuildPyUnicode.proto (used by COrdinalToPyUnicode) */ +static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, const char* chars, int clength, + int prepend_sign, char padding_char); + +/* COrdinalToPyUnicode.proto (used by CIntToPyUnicode) */ +static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value); +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t width, char padding_char); + +/* GCCDiagnostics.proto (used by CIntToPyUnicode) */ +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + +/* IncludeStdlibH.proto (used by CIntToPyUnicode) */ +#include + +/* CIntToPyUnicode.proto */ +#define __Pyx_PyUnicode_From_int(value, width, padding_char, format_char) (\ + ((format_char) == ('c')) ?\ + __Pyx_uchar___Pyx_PyUnicode_From_int(value, width, padding_char) :\ + __Pyx____Pyx_PyUnicode_From_int(value, width, padding_char, format_char)\ + ) +static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char); +static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char); + +/* CIntToPyUnicode.proto */ +#define __Pyx_PyUnicode_From_Py_ssize_t(value, width, padding_char, format_char) (\ + ((format_char) == ('c')) ?\ + __Pyx_uchar___Pyx_PyUnicode_From_Py_ssize_t(value, width, padding_char) :\ + __Pyx____Pyx_PyUnicode_From_Py_ssize_t(value, width, padding_char, format_char)\ + ) +static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char); +static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char); + +/* JoinPyUnicode.export */ +static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char); + +/* PyObjectFormatSimple.proto */ +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + PyObject_Format(s, f)) +#elif CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_repr(s) :\ + likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_repr(s) :\ + PyObject_Format(s, f)) +#else + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + PyObject_Format(s, f)) +#endif + +CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *); /*proto*/ +/* GetAttr.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil, unsafe_shared)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck, unsafe_shared) :\ + (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, has_gil, unsafe_shared)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck, unsafe_shared) :\ + (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, int unsafe_shared); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil, unsafe_shared)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck, unsafe_shared) :\ + (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, int unsafe_shared); +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, int unsafe_shared); + +/* 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 + +/* RejectKeywords.export */ +static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds); + +/* PyTypeError_Check.proto */ +#define __Pyx_PyExc_TypeError_Check(obj) __Pyx_TypeCheck(obj, PyExc_TypeError) + +/* DivInt[Py_ssize_t].proto */ +static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t, Py_ssize_t, int b_is_constant); + +/* UnaryNegOverflows.proto */ +#define __Pyx_UNARY_NEG_WOULD_OVERFLOW(x)\ + (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x))) + +/* GetAttr3.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); + +/* PyDictVersioning.proto (used by GetModuleGlobalName) */ +#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_XNewRef(__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_mstate_global->__pyx_d))) ?\ + (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ + __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ + PY_UINT64_T __pyx_dict_version;\ + PyObject *__pyx_dict_cached_value;\ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); +#else +#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) +#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); +#endif + +/* AssertionsEnabled.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX >= 0x030C0000 + static int __pyx_assertions_enabled_flag; + #define __pyx_assertions_enabled() (__pyx_assertions_enabled_flag) + #if __clang__ || __GNUC__ + __attribute__((no_sanitize("thread"))) + #endif + static int __Pyx_init_assertions_enabled(void) { + PyObject *builtins, *debug, *debug_str; + int flag; + builtins = PyEval_GetBuiltins(); + if (!builtins) goto bad; + debug_str = PyUnicode_FromStringAndSize("__debug__", 9); + if (!debug_str) goto bad; + debug = PyObject_GetItem(builtins, debug_str); + Py_DECREF(debug_str); + if (!debug) goto bad; + flag = PyObject_IsTrue(debug); + Py_DECREF(debug); + if (flag == -1) goto bad; + __pyx_assertions_enabled_flag = flag; + return 0; + bad: + __pyx_assertions_enabled_flag = 1; + return -1; + } +#else + #define __Pyx_init_assertions_enabled() (0) + #define __pyx_assertions_enabled() (!Py_OptimizeFlag) +#endif + +/* PyAssertionError_Check.proto */ +#define __Pyx_PyExc_AssertionError_Check(obj) __Pyx_TypeCheck(obj, PyExc_AssertionError) + +/* 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 (used by SaveResetException) */ +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE +static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); +#endif + +/* SaveResetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +#else +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/* GetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* SwapException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* HasAttr.proto (used by ImportImpl) */ +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_HasAttr(o, n) PyObject_HasAttrWithError(o, n) +#else +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); +#endif + +/* ImportImpl.export */ +static PyObject *__Pyx__Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, PyObject *moddict, int level); + +/* Import.proto */ +static CYTHON_INLINE PyObject *__Pyx_Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, int level); + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); +#else +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2) { + return PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2); +} +#endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) +#ifdef PyExceptionInstance_Check + #define __Pyx_PyBaseException_Check(obj) PyExceptionInstance_Check(obj) +#else + #define __Pyx_PyBaseException_Check(obj) __Pyx_TypeCheck(obj, PyExc_BaseException) +#endif + +CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +/* ListCompAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len)) { + Py_INCREF(x); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + L->ob_item[len] = x; + #else + PyList_SET_ITEM(list, len, x); + #endif + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) +#endif + +/* PySequenceMultiply.proto */ +#define __Pyx_PySequence_Multiply_Left(mul, seq) __Pyx_PySequence_Multiply(seq, mul) +#if !CYTHON_USE_TYPE_SLOTS +#define __Pyx_PySequence_Multiply PySequence_Repeat +#else +static CYTHON_INLINE PyObject* __Pyx_PySequence_Multiply(PyObject *seq, Py_ssize_t mul); +#endif + +/* PyObjectFormatAndDecref.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f); +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f); + +/* PyObjectFormat.proto */ +#if CYTHON_USE_UNICODE_WRITER +static PyObject* __Pyx_PyObject_Format(PyObject* s, PyObject* f); +#else +#define __Pyx_PyObject_Format(s, f) PyObject_Format(s, f) +#endif + +/* SetItemInt.proto */ +#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil, unsafe_shared)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck, unsafe_shared) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ + __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) +static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, + int is_list, int wraparound, int boundscheck, int unsafe_shared); + +/* RaiseUnboundLocalError.proto */ +static void __Pyx_RaiseUnboundLocalError(const char *varname); + +/* PyIndexError_Check.proto */ +#define __Pyx_PyExc_IndexError_Check(obj) __Pyx_TypeCheck(obj, PyExc_IndexError) + +/* DivInt[long].proto */ +static CYTHON_INLINE long __Pyx_div_long(long, long, int b_is_constant); + +/* PyImportError_Check.proto */ +#define __Pyx_PyExc_ImportError_Check(obj) __Pyx_TypeCheck(obj, PyExc_ImportError) + +/* PyObjectVectorCallKwBuilder.proto */ +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n); +#if CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03090000 +#define __Pyx_Object_Vectorcall_CallFromBuilder PyObject_Vectorcall +#else +#define __Pyx_Object_Vectorcall_CallFromBuilder _PyObject_Vectorcall +#endif +#define __Pyx_MakeVectorcallBuilderKwds(n) PyTuple_New(n) +static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n); +static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n); +#else +#define __Pyx_Object_Vectorcall_CallFromBuilder __Pyx_PyObject_FastCallDict +#define __Pyx_MakeVectorcallBuilderKwds(n) __Pyx_PyDict_NewPresized(n) +#define __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n) PyDict_SetItem(builder, key, value) +#define __Pyx_VectorcallBuilder_AddArgStr(key, value, builder, args, n) PyDict_SetItemString(builder, key, value) +#endif + +/* IterFinish.proto */ +static CYTHON_INLINE int __Pyx_IterFinish(void); + +/* UnpackItemEndCheck.proto */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); + +/* BufferIndexError.proto */ +static void __Pyx_RaiseBufferIndexError(int axis); + +/* PyDictContains.proto */ +static CYTHON_INLINE int __Pyx_PyDict_ContainsTF(PyObject* item, PyObject* dict, int eq) { + int result = PyDict_Contains(dict, item); + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +/* DictGetItem.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key); +#define __Pyx_PyObject_Dict_GetItem(obj, name)\ + (likely(PyDict_CheckExact(obj)) ?\ + __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name)) +#else +#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key) +#define __Pyx_PyObject_Dict_GetItem(obj, name) PyObject_GetItem(obj, name) +#endif + +/* pyint_simplify.proto */ +static CYTHON_INLINE int __Pyx_PyInt_FromNumber(PyObject **number_var, const char *argname, int accept_none); + +/* 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); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + L->ob_item[len] = x; + #else + PyList_SET_ITEM(list, len, x); + #endif + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_PyList_Append(L,x) PyList_Append(L,x) +#endif + +/* pep479.proto */ +static void __Pyx_Generator_Replace_StopIteration(int in_async_gen); + +/* PyLongBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static CYTHON_INLINE PyObject* __Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyLong_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) +#endif + +/* PyObjectDelAttr.proto (used by PyObjectSetAttrStr) */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 +#define __Pyx_PyObject_DelAttr(o, n) PyObject_SetAttr(o, n, NULL) +#else +#define __Pyx_PyObject_DelAttr(o, n) PyObject_DelAttr(o, n) +#endif + +/* PyObjectSetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_SetAttrStr(o, n, NULL) +static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value); +#else +#define __Pyx_PyObject_DelAttrStr(o,n) __Pyx_PyObject_DelAttr(o,n) +#define __Pyx_PyObject_SetAttrStr(o,n,v) PyObject_SetAttr(o,n,v) +#endif + +/* PyObjectCallNoArg.proto (used by pyfrozenset_new) */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); + +/* pyfrozenset_new.proto (used by PySetContains) */ +static CYTHON_INLINE PyObject* __Pyx_PyFrozenSet_New(PyObject* it); + +/* PySetContains.proto */ +static CYTHON_INLINE int __Pyx_PySet_ContainsTF(PyObject* key, PyObject* set, int eq); + +/* PyRange_Check.proto */ +#if CYTHON_COMPILING_IN_PYPY && !defined(PyRange_Check) + #define PyRange_Check(obj) __Pyx_TypeCheck((obj), &PyRange_Type) +#endif + +/* set_iter.proto */ +static CYTHON_INLINE PyObject* __Pyx_set_iterator(PyObject* iterable, int is_set, + Py_ssize_t* p_orig_length, int* p_source_is_set); +static CYTHON_INLINE int __Pyx_set_iter_next( + PyObject* iter_obj, Py_ssize_t orig_length, + Py_ssize_t* ppos, PyObject **value, + int source_is_set); + +/* py_set_discard.proto */ +static CYTHON_INLINE int __Pyx_PySet_Discard(PyObject *set, PyObject *key); + +/* AllocateExtensionType.proto */ +static PyObject *__Pyx_AllocateExtensionType(PyTypeObject *t, int is_final); + +/* CallTypeTraverse.proto */ +#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) +#define __Pyx_call_type_traverse(o, always_call, visit, arg) 0 +#else +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg); +#endif + +/* CheckTypeForFreelists.proto */ +#if CYTHON_USE_FREELISTS +#if CYTHON_USE_TYPE_SPECS +#define __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(t, expected_tp, expected_size) ((int) ((t) == (expected_tp))) +#define __PYX_CHECK_TYPE_FOR_FREELIST_FLAGS Py_TPFLAGS_IS_ABSTRACT +#else +#define __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(t, expected_tp, expected_size) ((int) ((t)->tp_basicsize == (expected_size))) +#define __PYX_CHECK_TYPE_FOR_FREELIST_FLAGS (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE) +#endif +#define __PYX_CHECK_TYPE_FOR_FREELISTS(t, expected_tp, expected_size)\ + (__PYX_CHECK_FINAL_TYPE_FOR_FREELISTS((t), (expected_tp), (expected_size)) &\ + (int) (!__Pyx_PyType_HasFeature((t), __PYX_CHECK_TYPE_FOR_FREELIST_FLAGS))) +#endif + +/* DeallocKeepAlive.proto */ +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __Pyx_DeallocKeepAliveBegin(o) do {\ + _Py_atomic_store_uintptr_relaxed(&(o)->ob_tid, _Py_ThreadId());\ + _Py_atomic_store_uint32_relaxed(&(o)->ob_ref_local, 1);\ + _Py_atomic_store_ssize_relaxed(&(o)->ob_ref_shared, 0);\ + } while (0) +#define __Pyx_DeallocKeepAliveEnd(o)\ + _Py_atomic_store_uint32_relaxed(&(o)->ob_ref_local, 0) +#else +#define __Pyx_DeallocKeepAliveBegin(o) __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1) +#define __Pyx_DeallocKeepAliveEnd(o) __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1) +#endif + +/* LimitedApiGetTypeDict.proto (used by SetItemOnTypeDict) */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp); +#endif + +/* SetItemOnTypeDict.proto (used by FixUpExtensionType) */ +static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v); +#define __Pyx_SetItemOnTypeDict(tp, k, v) __Pyx__SetItemOnTypeDict((PyTypeObject*)tp, k, v) + +/* FixUpExtensionType.proto */ +static CYTHON_INLINE int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); + +/* PyObjectGetMethod.proto (used by PyObjectCallMethod0) */ +#if !(CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))) +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); +#endif + +/* PyObjectCallMethod0.proto (used by PyType_Ready) */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); + +/* ValidateBasesTuple.proto (used by PyType_Ready) */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); +#endif + +/* PyType_Ready.proto */ +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); + +/* SetVTable.proto */ +static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); + +/* GetVTable.proto (used by MergeVTables) */ +static void* __Pyx_GetVtable(PyTypeObject *type); + +/* MergeVTables.proto */ +static int __Pyx_MergeVtables(PyTypeObject *type); + +/* DelItemOnTypeDict.proto (used by SetupReduce) */ +static int __Pyx__DelItemOnTypeDict(PyTypeObject *tp, PyObject *k); +#define __Pyx_DelItemOnTypeDict(tp, k) __Pyx__DelItemOnTypeDict((PyTypeObject*)tp, k) + +/* SetupReduce.proto */ +static int __Pyx_setup_reduce(PyObject* type_obj); + +/* TypeImport.proto */ +#ifndef __PYX_HAVE_RT_ImportType_proto_3_2_9 +#define __PYX_HAVE_RT_ImportType_proto_3_2_9 +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L +#include +#endif +#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L +#define __PYX_GET_STRUCT_ALIGNMENT_3_2_9(s) alignof(s) +#else +#define __PYX_GET_STRUCT_ALIGNMENT_3_2_9(s) sizeof(void*) +#endif +enum __Pyx_ImportType_CheckSize_3_2_9 { + __Pyx_ImportType_CheckSize_Error_3_2_9 = 0, + __Pyx_ImportType_CheckSize_Warn_3_2_9 = 1, + __Pyx_ImportType_CheckSize_Ignore_3_2_9 = 2 +}; +static PyTypeObject *__Pyx_ImportType_3_2_9(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_2_9 check_size); +#endif + +/* dict_setdefault.proto (used by FetchCommonType) */ +static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value); + +/* AddModuleRef.proto (used by FetchSharedCythonModule) */ +#if ((CYTHON_COMPILING_IN_CPYTHON_FREETHREADING ) ||\ + __PYX_LIMITED_VERSION_HEX < 0x030d0000) + static PyObject *__Pyx_PyImport_AddModuleRef(const char *name); +#else + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#endif + +/* FetchSharedCythonModule.proto (used by FetchCommonType) */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* FetchCommonType.proto (used by CommonTypesMetaclass) */ +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases); + +/* CommonTypesMetaclass.proto (used by CythonFunctionShared) */ +static int __pyx_CommonTypesMetaclass_init(PyObject *module); +#define __Pyx_CommonTypesMetaclass_USED + +/* PyMethodNew.proto (used by CythonFunctionShared) */ +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ); + +/* PyVectorcallFastCallDict.proto (used by CythonFunctionShared) */ +#if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); +#endif + +/* CythonFunctionShared.proto (used by CythonFunction) */ +#define __Pyx_CyFunction_USED +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#else + #define __Pyx_CyFunction_GetClassObj(f)\ + ((PyObject*) ((PyCMethodObject *) (f))->mm_class) +#endif +#define __Pyx_CyFunction_SetClassObj(f, classobj)\ + __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject_HEAD + PyObject *func; +#elif PY_VERSION_HEX < 0x030900B1 + PyCFunctionObject func; +#else + PyCMethodObject func; +#endif +#if CYTHON_COMPILING_IN_LIMITED_API && CYTHON_METH_FASTCALL + __pyx_vectorcallfunc func_vectorcall; +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_weakreflist; +#endif +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_dict; +#endif + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_classobj; +#endif + PyObject *defaults; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; + PyObject *func_is_coroutine; +} __pyx_CyFunctionObject; +#undef __Pyx_CyOrPyCFunction_Check +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_mstate_global->__pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_mstate_global->__pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_mstate_global->__pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)); +#undef __Pyx_IsSameCFunction +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); +static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, + PyTypeObject *defaults_type); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(PyObject *module); +#if CYTHON_METH_FASTCALL +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#if CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) +#else +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) +#endif +#endif + +/* CythonFunction.proto */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); + +/* ListPack.proto */ +static PyObject *__Pyx_PyList_Pack(Py_ssize_t n, ...); + +/* CLineInTraceback.proto (used by AddTraceback) */ +#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#else +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#endif + +/* CodeObjectCache.proto (used by AddTraceback) */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject __Pyx_CachedCodeObjectType; +#else +typedef PyCodeObject __Pyx_CachedCodeObjectType; +#endif +typedef struct { + __Pyx_CachedCodeObjectType* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_int_type accessor_count; + #endif +}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* 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; + +/* MemviewRefcount.proto */ +static CYTHON_INLINE int __pyx_add_acquisition_count_locked( + __pyx_atomic_int_type *acquisition_count, PyThread_type_lock lock); +static CYTHON_INLINE int __pyx_sub_acquisition_count_locked( + __pyx_atomic_int_type *acquisition_count, PyThread_type_lock lock); +#define __pyx_get_slice_count_pointer(memview) (&memview->acquisition_count) +#define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__) +#define __PYX_XCLEAR_MEMVIEW(slice, have_gil) __Pyx_XCLEAR_MEMVIEW(slice, have_gil, __LINE__) +static CYTHON_INLINE void __Pyx_INC_MEMVIEW(__Pyx_memviewslice *, int, int); +static CYTHON_INLINE void __Pyx_XCLEAR_MEMVIEW(__Pyx_memviewslice *, int, int); + +/* 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); + +/* MemviewSliceInit.proto */ +static int __Pyx_init_memviewslice( + struct __pyx_memoryview_obj *memview, + int ndim, + __Pyx_memviewslice *memviewslice, + int memview_is_new_reference); + +/* SliceMemoryviewSlice.proto */ +static CYTHON_INLINE int __pyx_memoryview_slice_memviewslice( + __Pyx_memviewslice *dst, + Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, + int dim, int new_ndim, int *suboffset_dim, + Py_ssize_t start, Py_ssize_t stop, Py_ssize_t step, + int have_start, int have_stop, int have_step, + int is_slice); + +/* MemviewDtypeToObject.proto */ +static CYTHON_INLINE PyObject *__pyx_memview_get_nn___pyx_t_5numpy_int8_t(const char *itemp); +static CYTHON_INLINE int __pyx_memview_set_nn___pyx_t_5numpy_int8_t(char *itemp, PyObject *obj); + +/* IsLittleEndian.proto (used by BufferFormatCheck) */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); + +/* BufferFormatCheck.proto (used by MemviewSliceValidateAndInit) */ +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, + const __Pyx_TypeInfo* type); + +/* TypeInfoCompare.proto (used by MemviewSliceValidateAndInit) */ +static int __pyx_typeinfo_cmp(const __Pyx_TypeInfo *a, const __Pyx_TypeInfo *b); + +/* MemviewSliceValidateAndInit.export */ +static int __Pyx_ValidateAndInit_memviewslice( + int *axes_specs, + int c_or_f_flag, + int buf_flags, + int ndim, + const __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___pyx_t_5numpy_int8_t(PyObject *, int writable_flag); + +/* CheckUnpickleChecksum.proto */ +static CYTHON_INLINE int __Pyx_CheckUnpickleChecksum(long checksum, long checksum1, long checksum2, long checksum3, const char *members); + +/* RealImag.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #define __Pyx_CREAL(z) ((z).real()) + #define __Pyx_CIMAG(z) ((z).imag()) + #else + #define __Pyx_CREAL(z) (__real__(z)) + #define __Pyx_CIMAG(z) (__imag__(z)) + #endif +#else + #define __Pyx_CREAL(z) ((z).real) + #define __Pyx_CIMAG(z) ((z).imag) +#endif +#if defined(__cplusplus) && CYTHON_CCOMPLEX\ + && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) + #define __Pyx_SET_CREAL(z,x) ((z).real(x)) + #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) +#else + #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) + #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) +#endif + +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #define __Pyx_c_eq_float(a, b) ((a)==(b)) + #define __Pyx_c_sum_float(a, b) ((a)+(b)) + #define __Pyx_c_diff_float(a, b) ((a)-(b)) + #define __Pyx_c_prod_float(a, b) ((a)*(b)) + #define __Pyx_c_quot_float(a, b) ((a)/(b)) + #define __Pyx_c_neg_float(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_float(z) ((z)==(float)0) + #define __Pyx_c_conj_float(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_float(z) (::std::abs(z)) + #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_float(z) ((z)==0) + #define __Pyx_c_conj_float(z) (conjf(z)) + #if 1 + #define __Pyx_c_abs_float(z) (cabsf(z)) + #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); + #if 1 + static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); + #endif +#endif + +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #define __Pyx_c_eq_double(a, b) ((a)==(b)) + #define __Pyx_c_sum_double(a, b) ((a)+(b)) + #define __Pyx_c_diff_double(a, b) ((a)-(b)) + #define __Pyx_c_prod_double(a, b) ((a)*(b)) + #define __Pyx_c_quot_double(a, b) ((a)/(b)) + #define __Pyx_c_neg_double(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_double(z) ((z)==(double)0) + #define __Pyx_c_conj_double(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_double(z) (::std::abs(z)) + #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_double(z) ((z)==0) + #define __Pyx_c_conj_double(z) (conj(z)) + #if 1 + #define __Pyx_c_abs_double(z) (cabs(z)) + #define __Pyx_c_pow_double(a, b) (cpow(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); + #if 1 + static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); + #endif +#endif + +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #define __Pyx_c_eq_long__double(a, b) ((a)==(b)) + #define __Pyx_c_sum_long__double(a, b) ((a)+(b)) + #define __Pyx_c_diff_long__double(a, b) ((a)-(b)) + #define __Pyx_c_prod_long__double(a, b) ((a)*(b)) + #define __Pyx_c_quot_long__double(a, b) ((a)/(b)) + #define __Pyx_c_neg_long__double(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_long__double(z) ((z)==(long double)0) + #define __Pyx_c_conj_long__double(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_long__double(z) (::std::abs(z)) + #define __Pyx_c_pow_long__double(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_long__double(z) ((z)==0) + #define __Pyx_c_conj_long__double(z) (conjl(z)) + #if 1 + #define __Pyx_c_abs_long__double(z) (cabsl(z)) + #define __Pyx_c_pow_long__double(a, b) (cpowl(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_sum_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_diff_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_prod_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_quot_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_neg_long__double(__pyx_t_long_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_long__double(__pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_conj_long__double(__pyx_t_long_double_complex); + #if 1 + static CYTHON_INLINE long double __Pyx_c_abs_long__double(__pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_pow_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); + #endif +#endif + +/* MemviewSliceCopy.proto */ +static __Pyx_memviewslice +__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, + const char *mode, int ndim, + size_t sizeof_dtype, int contig_flag, + int dtype_is_object); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_npy_int8(npy_int8 value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE npy_int8 __Pyx_PyLong_As_npy_int8(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value); + +/* PyObjectCall2Args.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); + +/* PyObjectCallMethod1.proto */ +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); + +/* UpdateUnpickledDict.proto */ +static int __Pyx_UpdateUnpickledDict(PyObject *obj, PyObject *state, Py_ssize_t index); + +/* CIntFromPy.proto */ +static CYTHON_INLINE char __Pyx_PyLong_As_char(PyObject *); + +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_PyType_GetFullyQualifiedName PyType_GetFullyQualifiedName +#else +static __Pyx_TypeName __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp); +#endif +#else // !LIMITED_API +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetFullyQualifiedName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + +/* GetRuntimeVersion.proto */ +#if __PYX_LIMITED_VERSION_HEX < 0x030b0000 +static unsigned long __Pyx_cached_runtime_version = 0; +static void __Pyx_init_runtime_version(void); +#else +#define __Pyx_init_runtime_version() +#endif +static unsigned long __Pyx_get_runtime_version(void); + +/* IterNextPlain.proto (used by CoroutineBase) */ +static CYTHON_INLINE PyObject *__Pyx_PyIter_Next_Plain(PyObject *iterator); +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +static PyObject *__Pyx_GetBuiltinNext_LimitedAPI(void); +#endif + +/* ReturnWithStopIteration.proto (used by CoroutineBase) */ +static CYTHON_INLINE void __Pyx_ReturnWithStopIteration(PyObject* value, int async, int iternext); + +/* CoroutineBase.proto (used by Generator) */ +struct __pyx_CoroutineObject; +typedef PyObject *(*__pyx_coroutine_body_t)(struct __pyx_CoroutineObject *, PyThreadState *, PyObject *); +#if CYTHON_USE_EXC_INFO_STACK +#define __Pyx_ExcInfoStruct _PyErr_StackItem +#else +typedef struct { + PyObject *exc_type; + PyObject *exc_value; + PyObject *exc_traceback; +} __Pyx_ExcInfoStruct; +#endif +typedef struct __pyx_CoroutineObject { + PyObject_HEAD + __pyx_coroutine_body_t body; + PyObject *closure; + __Pyx_ExcInfoStruct gi_exc_state; +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *gi_weakreflist; +#endif + PyObject *classobj; + PyObject *yieldfrom; + __Pyx_pyiter_sendfunc yieldfrom_am_send; + PyObject *gi_name; + PyObject *gi_qualname; + PyObject *gi_modulename; + PyObject *gi_code; + PyObject *gi_frame; +#if CYTHON_USE_SYS_MONITORING && (CYTHON_PROFILE || CYTHON_TRACE) + PyMonitoringState __pyx_pymonitoring_state[__Pyx_MonitoringEventTypes_CyGen_count]; + uint64_t __pyx_pymonitoring_version; +#endif + int resume_label; + char is_running; +} __pyx_CoroutineObject; +static __pyx_CoroutineObject *__Pyx__Coroutine_New( + PyTypeObject *type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name); +static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( + __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name); +static CYTHON_INLINE void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *self); +static int __Pyx_Coroutine_clear(PyObject *self); +static __Pyx_PySendResult __Pyx_Coroutine_AmSend(PyObject *self, PyObject *value, PyObject **retval); +static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value); +static __Pyx_PySendResult __Pyx_Coroutine_Close(PyObject *self, PyObject **retval); +static PyObject *__Pyx_Coroutine_Throw(PyObject *gen, PyObject *args); +#if CYTHON_USE_EXC_INFO_STACK +#define __Pyx_Coroutine_SwapException(self) +#define __Pyx_Coroutine_ResetAndClearException(self) __Pyx_Coroutine_ExceptionClear(&(self)->gi_exc_state) +#else +#define __Pyx_Coroutine_SwapException(self) {\ + __Pyx_ExceptionSwap(&(self)->gi_exc_state.exc_type, &(self)->gi_exc_state.exc_value, &(self)->gi_exc_state.exc_traceback);\ + __Pyx_Coroutine_ResetFrameBackpointer(&(self)->gi_exc_state);\ + } +#define __Pyx_Coroutine_ResetAndClearException(self) {\ + __Pyx_ExceptionReset((self)->gi_exc_state.exc_type, (self)->gi_exc_state.exc_value, (self)->gi_exc_state.exc_traceback);\ + (self)->gi_exc_state.exc_type = (self)->gi_exc_state.exc_value = (self)->gi_exc_state.exc_traceback = NULL;\ + } +#endif +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyGen_FetchStopIterationValue(pvalue)\ + __Pyx_PyGen__FetchStopIterationValue(__pyx_tstate, pvalue) +#else +#define __Pyx_PyGen_FetchStopIterationValue(pvalue)\ + __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, pvalue) +#endif +static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *tstate, PyObject **pvalue); +static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state); +static char __Pyx_Coroutine_test_and_set_is_running(__pyx_CoroutineObject *gen); +static void __Pyx_Coroutine_unset_is_running(__pyx_CoroutineObject *gen); +static char __Pyx_Coroutine_get_is_running(__pyx_CoroutineObject *gen); +static PyObject *__Pyx_Coroutine_get_is_running_getter(PyObject *gen, void *closure); +#if __PYX_HAS_PY_AM_SEND == 2 +static void __Pyx_SetBackportTypeAmSend(PyTypeObject *type, __Pyx_PyAsyncMethodsStruct *static_amsend_methods, __Pyx_pyiter_sendfunc am_send); +#endif +static PyObject *__Pyx_Coroutine_fail_reduce_ex(PyObject *self, PyObject *arg); + +/* Generator.proto */ +#define __Pyx_Generator_USED +#define __Pyx_Generator_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_mstate_global->__pyx_GeneratorType) +#define __Pyx_Generator_New(body, code, closure, name, qualname, module_name)\ + __Pyx__Coroutine_New(__pyx_mstate_global->__pyx_GeneratorType, body, code, closure, name, qualname, module_name) +static PyObject *__Pyx_Generator_Next(PyObject *self); +static int __pyx_Generator_init(PyObject *module); +static CYTHON_INLINE PyObject *__Pyx_Generator_GetInlinedResult(PyObject *self); + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); + +/* DecompressString.proto */ +static PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int algo); + +/* MultiPhaseInitModuleState.proto */ +#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE +static PyObject *__Pyx_State_FindModule(void*); +static int __Pyx_State_AddModule(PyObject* module, void*); +static int __Pyx_State_RemoveModule(void*); +#elif CYTHON_USE_MODULE_STATE +#define __Pyx_State_FindModule PyState_FindModule +#define __Pyx_State_AddModule PyState_AddModule +#define __Pyx_State_RemoveModule PyState_RemoveModule +#endif + +/* #### Code section: module_declarations ### */ +/* CythonABIVersion.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API + #if CYTHON_METH_FASTCALL + #define __PYX_FASTCALL_ABI_SUFFIX "_fastcall" + #else + #define __PYX_FASTCALL_ABI_SUFFIX + #endif + #define __PYX_LIMITED_ABI_SUFFIX "limited" __PYX_FASTCALL_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX +#else + #define __PYX_LIMITED_ABI_SUFFIX +#endif +#if __PYX_HAS_PY_AM_SEND == 1 + #define __PYX_AM_SEND_ABI_SUFFIX +#elif __PYX_HAS_PY_AM_SEND == 2 + #define __PYX_AM_SEND_ABI_SUFFIX "amsendbackport" +#else + #define __PYX_AM_SEND_ABI_SUFFIX "noamsend" +#endif +#ifndef __PYX_MONITORING_ABI_SUFFIX + #define __PYX_MONITORING_ABI_SUFFIX +#endif +#if CYTHON_USE_TP_FINALIZE + #define __PYX_TP_FINALIZE_ABI_SUFFIX +#else + #define __PYX_TP_FINALIZE_ABI_SUFFIX "nofinalize" +#endif +#if CYTHON_USE_FREELISTS || !defined(__Pyx_AsyncGen_USED) + #define __PYX_FREELISTS_ABI_SUFFIX +#else + #define __PYX_FREELISTS_ABI_SUFFIX "nofreelists" +#endif +#define CYTHON_ABI __PYX_ABI_VERSION __PYX_LIMITED_ABI_SUFFIX __PYX_MONITORING_ABI_SUFFIX __PYX_TP_FINALIZE_ABI_SUFFIX __PYX_FREELISTS_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." + +static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self); /* proto*/ +static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto*/ +static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj); /* proto*/ +static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src); /* proto*/ +static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value); /* proto*/ +static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto*/ +static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/ +static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/ +static PyObject *__pyx_memoryview__get_base(struct __pyx_memoryview_obj *__pyx_v_self); /* proto*/ +static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/ +static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/ +static PyObject *__pyx_memoryviewslice__get_base(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_8itemsize_itemsize(PyArray_Descr *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_9alignment_alignment(PyArray_Descr *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_5numpy_5dtype_6fields_fields(PyArray_Descr *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_5numpy_5dtype_5names_names(PyArray_Descr *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyArray_ArrayDescr *__pyx_f_5numpy_5dtype_8subarray_subarray(PyArray_Descr *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_uint64 __pyx_f_5numpy_5dtype_5flags_flags(PyArray_Descr *__pyx_v_self); /* proto*/ +static CYTHON_INLINE int __pyx_f_5numpy_9broadcast_7numiter_numiter(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_intp __pyx_f_5numpy_9broadcast_4size_size(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_intp __pyx_f_5numpy_9broadcast_5index_index(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE int __pyx_f_5numpy_9broadcast_2nd_nd(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_intp *__pyx_f_5numpy_9broadcast_10dimensions_dimensions(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE void **__pyx_f_5numpy_9broadcast_5iters_iters(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_5numpy_7ndarray_4base_base(PyArrayObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyArray_Descr *__pyx_f_5numpy_7ndarray_5descr_descr(PyArrayObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE int __pyx_f_5numpy_7ndarray_4ndim_ndim(PyArrayObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_5shape_shape(PyArrayObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_7strides_strides(PyArrayObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_intp __pyx_f_5numpy_7ndarray_4size_size(PyArrayObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE char *__pyx_f_5numpy_7ndarray_4data_data(PyArrayObject *__pyx_v_self); /* proto*/ +static int __pyx_f_10blokus_gym_4core_13blokus_cython_5Board_is_cell_empty(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, int __pyx_v_x, int __pyx_v_y); /* proto*/ +static void __pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame__generate_action_space(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto*/ +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame__get_placed_squares(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_move); /* proto*/ +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame__get_placed_corners(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_move); /* proto*/ +static int __pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame_valid_move(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, int __pyx_v_player_idx, struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_move, int __pyx_skip_dispatch); /* proto*/ +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame_get_valid_actions(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, int __pyx_v_player_idx, int __pyx_skip_dispatch); /* proto*/ +static int __pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame_has_valid_moves(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, int __pyx_v_player_idx, int __pyx_skip_dispatch); /* proto*/ + +/* Module declarations from "cython.view" */ + +/* Module declarations from "cython.dataclasses" */ + +/* Module declarations from "cython" */ + +/* Module declarations from "libc.string" */ + +/* Module declarations from "libc.stdio" */ + +/* Module declarations from "__builtin__" */ + +/* Module declarations from "cpython.type" */ + +/* Module declarations from "cpython" */ + +/* Module declarations from "cpython.object" */ + +/* Module declarations from "cpython.ref" */ + +/* Module declarations from "numpy" */ + +/* Module declarations from "numpy" */ + +/* Module declarations from "blokus_gym.core.blokus_cython" */ +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__I1_squares = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__I2_squares = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__I3_squares = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__V3_squares = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__I4_squares = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__L4_squares = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__T4_squares = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__S4_squares = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__O4_squares = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__I5_squares = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__L5_squares = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__Y5_squares = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__N5_squares = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__T5_squares = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__U5_squares = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__V5_squares = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__W5_squares = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__Z5_squares = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__F5_squares = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__X5_squares = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython__P5_squares = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__I1 = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__I2 = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__I3 = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__V3 = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__I4 = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__L4 = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__T4 = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__S4 = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__O4 = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__I5 = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__L5 = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__Y5 = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__N5 = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__T5 = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__U5 = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__V5 = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__W5 = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__Z5 = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__F5 = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__X5 = 0; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_10blokus_gym_4core_13blokus_cython__P5 = 0; +static PyObject *__pyx_v_10blokus_gym_4core_13blokus_cython_STANDARD_PIECES = 0; +static PyObject *__pyx_collections_abc_Sequence = 0; +static PyObject *generic = 0; +static PyObject *strided = 0; +static PyObject *indirect = 0; +static PyObject *contiguous = 0; +static PyObject *indirect_contiguous = 0; +static int __pyx_memoryview_thread_locks_used; +static PyThread_type_lock __pyx_memoryview_thread_locks[8]; +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython_generate_orientations_cython(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *); /*proto*/ +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython_rotate_squares_cython(PyObject *, int); /*proto*/ +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython_normalize_squares_cython(PyObject *); /*proto*/ +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython_compute_corners_cython(PyObject *); /*proto*/ +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_Board__set_state(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *, PyObject *); /*proto*/ +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_Move__set_state(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *, PyObject *); /*proto*/ +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_PieceOrientation__set_state(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *, PyObject *); /*proto*/ +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_Piece__set_state(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *, PyObject *); /*proto*/ +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_PieceSet__set_state(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *, PyObject *); /*proto*/ +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_PlayerState__set_state(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *, PyObject *); /*proto*/ +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_BlokusGame__set_state(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *, PyObject *); /*proto*/ +static int __pyx_array_allocate_buffer(struct __pyx_array_obj *); /*proto*/ +static struct __pyx_array_obj *__pyx_array_new(PyObject *, Py_ssize_t, char *, char const *, char *); /*proto*/ +static PyObject *__pyx_memoryview_new(PyObject *, int, int, __Pyx_TypeInfo const *); /*proto*/ +static CYTHON_INLINE int __pyx_memoryview_check(PyObject *); /*proto*/ +static PyObject *_unellipsify(PyObject *, int); /*proto*/ +static int assert_direct_dimensions(Py_ssize_t *, int); /*proto*/ +static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *, PyObject *); /*proto*/ +static char *__pyx_pybuffer_index(Py_buffer *, char *, Py_ssize_t, Py_ssize_t); /*proto*/ +static int __pyx_memslice_transpose(__Pyx_memviewslice *); /*proto*/ +static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice, int, PyObject *(*)(char *), int (*)(char *, PyObject *), int); /*proto*/ +static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ +static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ +static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *); /*proto*/ +static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ +static Py_ssize_t abs_py_ssize_t(Py_ssize_t); /*proto*/ +static char __pyx_get_best_slice_order(__Pyx_memviewslice *, int); /*proto*/ +static void _copy_strided_to_strided(char *, Py_ssize_t *, char *, Py_ssize_t *, Py_ssize_t *, Py_ssize_t *, int, size_t); /*proto*/ +static void copy_strided_to_strided(__Pyx_memviewslice *, __Pyx_memviewslice *, int, size_t); /*proto*/ +static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *, int); /*proto*/ +static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *, Py_ssize_t *, Py_ssize_t, int, char); /*proto*/ +static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *, __Pyx_memviewslice *, char, int); /*proto*/ +static int __pyx_memoryview_err_extents(int, Py_ssize_t, Py_ssize_t); /*proto*/ +static int __pyx_memoryview_err_dim(PyObject *, PyObject *, int); /*proto*/ +static int __pyx_memoryview_err(PyObject *, PyObject *); /*proto*/ +static int __pyx_memoryview_err_no_memory(void); /*proto*/ +static int __pyx_memoryview_copy_contents(__Pyx_memviewslice, __Pyx_memviewslice, int, int, int); /*proto*/ +static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *, int, int); /*proto*/ +static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *, int, int, int); /*proto*/ +static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/ +static void __pyx_memoryview_refcount_objects_in_slice(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/ +static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *, int, size_t, void *, int); /*proto*/ +static void __pyx_memoryview__slice_assign_scalar(char *, Py_ssize_t *, Py_ssize_t *, int, size_t, void *); /*proto*/ +static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *, PyObject *); /*proto*/ +/* #### Code section: typeinfo ### */ +static const __Pyx_TypeInfo __Pyx_TypeInfo_nn___pyx_t_5numpy_int8_t = { "int8_t", NULL, sizeof(__pyx_t_5numpy_int8_t), { 0 }, 0, __PYX_IS_UNSIGNED(__pyx_t_5numpy_int8_t) ? 'U' : 'I', __PYX_IS_UNSIGNED(__pyx_t_5numpy_int8_t), 0 }; +/* #### Code section: before_global_var ### */ +#define __Pyx_MODULE_NAME "blokus_gym.core.blokus_cython" +extern int __pyx_module_is_main_blokus_gym__core__blokus_cython; +int __pyx_module_is_main_blokus_gym__core__blokus_cython = 0; + +/* Implementation of "blokus_gym.core.blokus_cython" */ +/* #### Code section: global_var ### */ +static PyObject *__pyx_builtin_enumerate; +static PyObject *__pyx_builtin_sum; +static PyObject *__pyx_builtin_min; +static PyObject *__pyx_builtin_max; +static PyObject *__pyx_builtin___import__; +static PyObject *__pyx_builtin_Ellipsis; +static PyObject *__pyx_builtin_id; +/* #### Code section: string_decls ### */ +static const char __pyx_k_c[] = "c"; +static const char __pyx_k_name[] = "name"; +static const char __pyx_k_fortran[] = "fortran"; +static const char __pyx_k_name_squares[] = "name, squares"; +static const char __pyx_k_occupied_cache_grid_size[] = "_occupied_cache, grid, size"; +static const char __pyx_k_orientation_id_piece_id_x_y[] = "orientation_id, piece_id, x, y"; +static const char __pyx_k_action_moves__actions_by_piece[] = "_action_moves, _actions_by_piece, _move_to_action, _starting_corners, board, board_size, corner_rule, current_player, game_over, num_players, piece_set, players, rounds"; +static const char __pyx_k_corners_orientation_id_piece_id[] = "corners, orientation_id, piece_id, squares"; +static const char __pyx_k_available_pieces_can_move_corner[] = "available_pieces, can_move, corners, has_started, idx, score"; +static const char __pyx_k_num_orientations_orientations_pi[] = "num_orientations, orientations, piece_id_map, piece_names, pieces"; +/* #### Code section: decls ### */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr); /* proto */ +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ +static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object); /* proto */ +static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board___init__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, int __pyx_v_size); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_2place(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, int __pyx_v_player_idx, PyObject *__pyx_v_squares); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_4clear(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_6is_empty(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, int __pyx_v_x, int __pyx_v_y); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_8in_bounds(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, int __pyx_v_x, int __pyx_v_y); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_10has_overlap(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, PyObject *__pyx_v_squares); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_12get_cell(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, int __pyx_v_x, int __pyx_v_y); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_14get_player_squares(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, int __pyx_v_player_idx); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_16get_player_occupied(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, int __pyx_v_player_idx); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_18get_player_corners(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, int __pyx_v_player_idx); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_20get_occupied(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_22is_full(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_24coverage(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_4size___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_4size_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_4grid___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_4grid_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_15_occupied_cache___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_15_occupied_cache_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_15_occupied_cache_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_26__reduce_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_28__setstate_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move___init__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_self, int __pyx_v_piece_id, int __pyx_v_orientation_id, int __pyx_v_x, int __pyx_v_y); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_2__repr__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_8piece_id___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_8piece_id_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_14orientation_id___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_14orientation_id_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_1x___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_1x_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_1y___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_1y_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_4__reduce_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_6__setstate_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation___init__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self, int __pyx_v_piece_id, int __pyx_v_orientation_id, PyObject *__pyx_v_squares, PyObject *__pyx_v_corners); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_8piece_id___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_8piece_id_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_14orientation_id___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_14orientation_id_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7squares___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7squares_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7squares_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7corners___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7corners_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7corners_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_2__reduce_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_4__setstate_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece___init__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_squares); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_4size___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_4name___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_4name_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_4name_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_7squares___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_7squares_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_7squares_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_2__reduce_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_4__setstate_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_8__init___genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet___init__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self, PyObject *__pyx_v_pieces_list); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_10num_pieces___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_2get_orientations(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self, int __pyx_v_piece_id); /* proto */ +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_4get_piece(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self, int __pyx_v_piece_id); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_6get_piece_id(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_6pieces___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_6pieces_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_6pieces_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_11piece_names___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_11piece_names_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_11piece_names_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_12piece_id_map___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_12piece_id_map_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_12piece_id_map_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_12orientations___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_12orientations_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_12orientations_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_16num_orientations___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_16num_orientations_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_8__reduce_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_10__setstate_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_24normalize_squares_cython_genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_24normalize_squares_cython_3genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState___init__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_3idx___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_3idx_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_16available_pieces___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_16available_pieces_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_16available_pieces_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_7corners___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_7corners_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_7corners_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_5score___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_5score_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_11has_started___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_11has_started_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_8can_move___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_8can_move_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_2__reduce_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_4__setstate_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame___init__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, int __pyx_v_board_size, struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_pieces, int __pyx_v_num_players, int __pyx_v_corner_rule); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_22_generate_action_space_genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_22_generate_action_space_3genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_11num_actions___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_2get_move(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, int __pyx_v_action); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_4get_action(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_move); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_6reset(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_8valid_move(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, int __pyx_v_player_idx, struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_move); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_10get_valid_actions(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, int __pyx_v_player_idx); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_12has_valid_moves(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, int __pyx_v_player_idx); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_14apply_move(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, int __pyx_v_player_idx, struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_move); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_16play_move(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, int __pyx_v_player_idx, int __pyx_v_action); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_18next_player(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_16_check_game_over_genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_16_check_game_over_3genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_20_check_game_over(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_22get_state(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_24copy(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_10board_size___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_10board_size_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_9piece_set___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_9piece_set_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_9piece_set_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_11num_players___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_11num_players_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_11corner_rule___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_11corner_rule_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_5board___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_5board_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_5board_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_7players___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_7players_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_7players_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_14current_player___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_14current_player_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_6rounds___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_6rounds_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_9game_over___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_9game_over_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_13_action_moves___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_13_action_moves_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_13_action_moves_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_15_move_to_action___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_15_move_to_action_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_15_move_to_action_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_actions_by_piece___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_actions_by_piece_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_actions_by_piece_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_starting_corners___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_starting_corners_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v_value); /* proto */ +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_starting_corners_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_26__reduce_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_28__setstate_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython___pyx_unpickle_Board(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_2__pyx_unpickle_Move(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_4__pyx_unpickle_PieceOrientation(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_6__pyx_unpickle_Piece(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8__pyx_unpickle_PieceSet(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10__pyx_unpickle_PlayerState(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_12__pyx_unpickle_BlokusGame(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_10blokus_gym_4core_13blokus_cython_Board(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython_Move(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython_PieceOrientation(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython_Piece(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython_PieceSet(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython_PlayerState(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython_BlokusGame(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +/* SmallCodeConfig */ +#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 + +typedef struct { + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; + PyTypeObject *__pyx_ptype_7cpython_4type_type; + PyTypeObject *__pyx_ptype_5numpy_dtype; + PyTypeObject *__pyx_ptype_5numpy_flatiter; + PyTypeObject *__pyx_ptype_5numpy_broadcast; + PyTypeObject *__pyx_ptype_5numpy_ndarray; + PyTypeObject *__pyx_ptype_5numpy_generic; + PyTypeObject *__pyx_ptype_5numpy_number; + PyTypeObject *__pyx_ptype_5numpy_integer; + PyTypeObject *__pyx_ptype_5numpy_signedinteger; + PyTypeObject *__pyx_ptype_5numpy_unsignedinteger; + PyTypeObject *__pyx_ptype_5numpy_inexact; + PyTypeObject *__pyx_ptype_5numpy_floating; + PyTypeObject *__pyx_ptype_5numpy_complexfloating; + PyTypeObject *__pyx_ptype_5numpy_flexible; + PyTypeObject *__pyx_ptype_5numpy_character; + PyTypeObject *__pyx_ptype_5numpy_ufunc; + PyObject *__pyx_type_10blokus_gym_4core_13blokus_cython_Board; + PyObject *__pyx_type_10blokus_gym_4core_13blokus_cython_Move; + PyObject *__pyx_type_10blokus_gym_4core_13blokus_cython_PieceOrientation; + PyObject *__pyx_type_10blokus_gym_4core_13blokus_cython_Piece; + PyObject *__pyx_type_10blokus_gym_4core_13blokus_cython_PieceSet; + PyObject *__pyx_type_10blokus_gym_4core_13blokus_cython_PlayerState; + PyObject *__pyx_type_10blokus_gym_4core_13blokus_cython_BlokusGame; + PyObject *__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr; + PyObject *__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr; + PyObject *__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr; + PyObject *__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr; + PyObject *__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr; + PyObject *__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr; + PyObject *__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr; + PyObject *__pyx_type___pyx_array; + PyObject *__pyx_type___pyx_MemviewEnum; + PyObject *__pyx_type___pyx_memoryview; + PyObject *__pyx_type___pyx_memoryviewslice; + PyTypeObject *__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board; + PyTypeObject *__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move; + PyTypeObject *__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation; + PyTypeObject *__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece; + PyTypeObject *__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet; + PyTypeObject *__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState; + PyTypeObject *__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame; + PyTypeObject *__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr; + PyTypeObject *__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr; + PyTypeObject *__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr; + PyTypeObject *__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr; + PyTypeObject *__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr; + PyTypeObject *__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr; + PyTypeObject *__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr; + PyTypeObject *__pyx_array_type; + PyTypeObject *__pyx_MemviewEnum_type; + PyTypeObject *__pyx_memoryview_type; + PyTypeObject *__pyx_memoryviewslice_type; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_items; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_pop; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_values; + PyObject *__pyx_slice[1]; + PyObject *__pyx_tuple[41]; + PyObject *__pyx_codeobj_tab[55]; + PyObject *__pyx_string_tab[348]; + PyObject *__pyx_number_tab[14]; +/* #### Code section: module_state_contents ### */ + +#if CYTHON_USE_FREELISTS +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr *__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr[8]; +int __pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr; +#endif + +#if CYTHON_USE_FREELISTS +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr *__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr[8]; +int __pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr; +#endif + +#if CYTHON_USE_FREELISTS +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr *__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr[8]; +int __pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr; +#endif + +#if CYTHON_USE_FREELISTS +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr *__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr[8]; +int __pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr; +#endif + +#if CYTHON_USE_FREELISTS +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr *__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr[8]; +int __pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr; +#endif + +#if CYTHON_USE_FREELISTS +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr *__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr[8]; +int __pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr; +#endif + +#if CYTHON_USE_FREELISTS +struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr *__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr[8]; +int __pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr; +#endif +/* CommonTypesMetaclass.module_state_decls */ +PyTypeObject *__pyx_CommonTypesMetaclassType; + +/* CachedMethodType.module_state_decls */ +#if CYTHON_COMPILING_IN_LIMITED_API +PyObject *__Pyx_CachedMethodType; +#endif + +/* CythonFunctionShared.module_state_decls */ +PyTypeObject *__pyx_CyFunctionType; + +/* CodeObjectCache.module_state_decls */ +struct __Pyx_CodeObjectCache __pyx_code_cache; + +/* IterNextPlain.module_state_decls */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +PyObject *__Pyx_GetBuiltinNext_LimitedAPI_cache; +#endif + +/* Generator.module_state_decls */ +PyTypeObject *__pyx_GeneratorType; + +/* #### Code section: module_state_end ### */ +} __pyx_mstatetype; + +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { +extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; +#endif + +#define __pyx_mstate_global (__Pyx_PyModule_GetState(__Pyx_State_FindModule(&__pyx_moduledef))) + +#define __pyx_m (__Pyx_State_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstatetype __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstatetype * const __pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: constant_name_defines ### */ +#define __pyx_kp_u_ __pyx_string_tab[0] +#define __pyx_kp_u_Buffer_view_does_not_expose_stri __pyx_string_tab[1] +#define __pyx_kp_u_Can_only_create_a_buffer_that_is __pyx_string_tab[2] +#define __pyx_kp_u_Cannot_assign_to_read_only_memor __pyx_string_tab[3] +#define __pyx_kp_u_Cannot_create_writable_memory_vi __pyx_string_tab[4] +#define __pyx_kp_u_Cannot_index_with_type __pyx_string_tab[5] +#define __pyx_kp_u_Cannot_transpose_memoryview_with __pyx_string_tab[6] +#define __pyx_kp_u_Dimension_d_is_not_direct __pyx_string_tab[7] +#define __pyx_kp_u_Empty_shape_tuple_for_cython_arr __pyx_string_tab[8] +#define __pyx_kp_u_Indirect_dimensions_not_supporte __pyx_string_tab[9] +#define __pyx_kp_u_Invalid_mode_expected_c_or_fortr __pyx_string_tab[10] +#define __pyx_kp_u_Invalid_shape_in_axis __pyx_string_tab[11] +#define __pyx_kp_u_MemoryView_of __pyx_string_tab[12] +#define __pyx_kp_u_Move_piece __pyx_string_tab[13] +#define __pyx_kp_u_Note_that_Cython_is_deliberately __pyx_string_tab[14] +#define __pyx_kp_u_Out_of_bounds_on_buffer_access_a __pyx_string_tab[15] +#define __pyx_kp_u_Unable_to_convert_item_to_object __pyx_string_tab[16] +#define __pyx_kp_u__2 __pyx_string_tab[17] +#define __pyx_kp_u__3 __pyx_string_tab[18] +#define __pyx_kp_u__4 __pyx_string_tab[19] +#define __pyx_kp_u__5 __pyx_string_tab[20] +#define __pyx_kp_u__6 __pyx_string_tab[21] +#define __pyx_kp_u__7 __pyx_string_tab[22] +#define __pyx_kp_u__8 __pyx_string_tab[23] +#define __pyx_kp_u_add_note __pyx_string_tab[24] +#define __pyx_kp_u_and __pyx_string_tab[25] +#define __pyx_kp_u_at_0x __pyx_string_tab[26] +#define __pyx_kp_u_blokus_gym_core_blokus_cython_py __pyx_string_tab[27] +#define __pyx_kp_u_collections_abc __pyx_string_tab[28] +#define __pyx_kp_u_contiguous_and_direct __pyx_string_tab[29] +#define __pyx_kp_u_contiguous_and_indirect __pyx_string_tab[30] +#define __pyx_kp_u_disable __pyx_string_tab[31] +#define __pyx_kp_u_enable __pyx_string_tab[32] +#define __pyx_kp_u_gc __pyx_string_tab[33] +#define __pyx_kp_u_got __pyx_string_tab[34] +#define __pyx_kp_u_got_differing_extents_in_dimensi __pyx_string_tab[35] +#define __pyx_kp_u_isenabled __pyx_string_tab[36] +#define __pyx_kp_u_itemsize_0_for_cython_array __pyx_string_tab[37] +#define __pyx_kp_u_no_default___reduce___due_to_non __pyx_string_tab[38] +#define __pyx_kp_u_numpy__core_multiarray_failed_to __pyx_string_tab[39] +#define __pyx_kp_u_numpy__core_umath_failed_to_impo __pyx_string_tab[40] +#define __pyx_kp_u_object __pyx_string_tab[41] +#define __pyx_kp_u_orient __pyx_string_tab[42] +#define __pyx_kp_u_pos __pyx_string_tab[43] +#define __pyx_kp_u_strided_and_direct __pyx_string_tab[44] +#define __pyx_kp_u_strided_and_direct_or_indirect __pyx_string_tab[45] +#define __pyx_kp_u_strided_and_indirect __pyx_string_tab[46] +#define __pyx_kp_u_stringsource __pyx_string_tab[47] +#define __pyx_kp_u_unable_to_allocate_array_data __pyx_string_tab[48] +#define __pyx_kp_u_unable_to_allocate_shape_and_str __pyx_string_tab[49] +#define __pyx_n_u_ASCII __pyx_string_tab[50] +#define __pyx_n_u_BlokusGame __pyx_string_tab[51] +#define __pyx_n_u_BlokusGame___reduce_cython __pyx_string_tab[52] +#define __pyx_n_u_BlokusGame___setstate_cython __pyx_string_tab[53] +#define __pyx_n_u_BlokusGame__check_game_over __pyx_string_tab[54] +#define __pyx_n_u_BlokusGame__generate_action_spac __pyx_string_tab[55] +#define __pyx_n_u_BlokusGame_apply_move __pyx_string_tab[56] +#define __pyx_n_u_BlokusGame_copy __pyx_string_tab[57] +#define __pyx_n_u_BlokusGame_get_action __pyx_string_tab[58] +#define __pyx_n_u_BlokusGame_get_move __pyx_string_tab[59] +#define __pyx_n_u_BlokusGame_get_state __pyx_string_tab[60] +#define __pyx_n_u_BlokusGame_get_valid_actions __pyx_string_tab[61] +#define __pyx_n_u_BlokusGame_has_valid_moves __pyx_string_tab[62] +#define __pyx_n_u_BlokusGame_next_player __pyx_string_tab[63] +#define __pyx_n_u_BlokusGame_play_move __pyx_string_tab[64] +#define __pyx_n_u_BlokusGame_reset __pyx_string_tab[65] +#define __pyx_n_u_BlokusGame_valid_move __pyx_string_tab[66] +#define __pyx_n_u_Board __pyx_string_tab[67] +#define __pyx_n_u_Board___reduce_cython __pyx_string_tab[68] +#define __pyx_n_u_Board___setstate_cython __pyx_string_tab[69] +#define __pyx_n_u_Board_clear __pyx_string_tab[70] +#define __pyx_n_u_Board_coverage __pyx_string_tab[71] +#define __pyx_n_u_Board_get_cell __pyx_string_tab[72] +#define __pyx_n_u_Board_get_occupied __pyx_string_tab[73] +#define __pyx_n_u_Board_get_player_corners __pyx_string_tab[74] +#define __pyx_n_u_Board_get_player_occupied __pyx_string_tab[75] +#define __pyx_n_u_Board_get_player_squares __pyx_string_tab[76] +#define __pyx_n_u_Board_has_overlap __pyx_string_tab[77] +#define __pyx_n_u_Board_in_bounds __pyx_string_tab[78] +#define __pyx_n_u_Board_is_empty __pyx_string_tab[79] +#define __pyx_n_u_Board_is_full __pyx_string_tab[80] +#define __pyx_n_u_Board_place __pyx_string_tab[81] +#define __pyx_n_u_Ellipsis __pyx_string_tab[82] +#define __pyx_n_u_F5 __pyx_string_tab[83] +#define __pyx_n_u_I1 __pyx_string_tab[84] +#define __pyx_n_u_I2 __pyx_string_tab[85] +#define __pyx_n_u_I3 __pyx_string_tab[86] +#define __pyx_n_u_I4 __pyx_string_tab[87] +#define __pyx_n_u_I5 __pyx_string_tab[88] +#define __pyx_n_u_L4 __pyx_string_tab[89] +#define __pyx_n_u_L5 __pyx_string_tab[90] +#define __pyx_n_u_Move __pyx_string_tab[91] +#define __pyx_n_u_Move___reduce_cython __pyx_string_tab[92] +#define __pyx_n_u_Move___setstate_cython __pyx_string_tab[93] +#define __pyx_n_u_N5 __pyx_string_tab[94] +#define __pyx_n_u_None __pyx_string_tab[95] +#define __pyx_n_u_O4 __pyx_string_tab[96] +#define __pyx_n_u_P5 __pyx_string_tab[97] +#define __pyx_n_u_Piece __pyx_string_tab[98] +#define __pyx_n_u_PieceOrientation __pyx_string_tab[99] +#define __pyx_n_u_PieceOrientation___reduce_cython __pyx_string_tab[100] +#define __pyx_n_u_PieceOrientation___setstate_cyth __pyx_string_tab[101] +#define __pyx_n_u_PieceSet __pyx_string_tab[102] +#define __pyx_n_u_PieceSet___reduce_cython __pyx_string_tab[103] +#define __pyx_n_u_PieceSet___setstate_cython __pyx_string_tab[104] +#define __pyx_n_u_PieceSet_get_orientations __pyx_string_tab[105] +#define __pyx_n_u_PieceSet_get_piece __pyx_string_tab[106] +#define __pyx_n_u_PieceSet_get_piece_id __pyx_string_tab[107] +#define __pyx_n_u_Piece___reduce_cython __pyx_string_tab[108] +#define __pyx_n_u_Piece___setstate_cython __pyx_string_tab[109] +#define __pyx_n_u_PlayerState __pyx_string_tab[110] +#define __pyx_n_u_PlayerState___reduce_cython __pyx_string_tab[111] +#define __pyx_n_u_PlayerState___setstate_cython __pyx_string_tab[112] +#define __pyx_n_u_Pyx_PyDict_NextRef __pyx_string_tab[113] +#define __pyx_n_u_S4 __pyx_string_tab[114] +#define __pyx_n_u_Sequence __pyx_string_tab[115] +#define __pyx_n_u_T4 __pyx_string_tab[116] +#define __pyx_n_u_T5 __pyx_string_tab[117] +#define __pyx_n_u_U5 __pyx_string_tab[118] +#define __pyx_n_u_V3 __pyx_string_tab[119] +#define __pyx_n_u_V5 __pyx_string_tab[120] +#define __pyx_n_u_View_MemoryView __pyx_string_tab[121] +#define __pyx_n_u_W5 __pyx_string_tab[122] +#define __pyx_n_u_X5 __pyx_string_tab[123] +#define __pyx_n_u_Y5 __pyx_string_tab[124] +#define __pyx_n_u_Z5 __pyx_string_tab[125] +#define __pyx_n_u__10 __pyx_string_tab[126] +#define __pyx_n_u_abc __pyx_string_tab[127] +#define __pyx_n_u_action __pyx_string_tab[128] +#define __pyx_n_u_allocate_buffer __pyx_string_tab[129] +#define __pyx_n_u_annotate __pyx_string_tab[130] +#define __pyx_n_u_apply_move __pyx_string_tab[131] +#define __pyx_n_u_asyncio_coroutines __pyx_string_tab[132] +#define __pyx_n_u_available_pieces __pyx_string_tab[133] +#define __pyx_n_u_base __pyx_string_tab[134] +#define __pyx_n_u_bint __pyx_string_tab[135] +#define __pyx_n_u_blokus_gym_core_blokus_cython __pyx_string_tab[136] +#define __pyx_n_u_board_size __pyx_string_tab[137] +#define __pyx_n_u_bool __pyx_string_tab[138] +#define __pyx_n_u_c __pyx_string_tab[139] +#define __pyx_n_u_can_move __pyx_string_tab[140] +#define __pyx_n_u_check_game_over __pyx_string_tab[141] +#define __pyx_n_u_check_game_over_locals_genexpr __pyx_string_tab[142] +#define __pyx_n_u_class __pyx_string_tab[143] +#define __pyx_n_u_class_getitem __pyx_string_tab[144] +#define __pyx_n_u_clear __pyx_string_tab[145] +#define __pyx_n_u_cline_in_traceback __pyx_string_tab[146] +#define __pyx_n_u_close __pyx_string_tab[147] +#define __pyx_n_u_copy __pyx_string_tab[148] +#define __pyx_n_u_corner_rule __pyx_string_tab[149] +#define __pyx_n_u_corners __pyx_string_tab[150] +#define __pyx_n_u_count __pyx_string_tab[151] +#define __pyx_n_u_coverage __pyx_string_tab[152] +#define __pyx_n_u_current_player __pyx_string_tab[153] +#define __pyx_n_u_cx __pyx_string_tab[154] +#define __pyx_n_u_cy __pyx_string_tab[155] +#define __pyx_n_u_dict __pyx_string_tab[156] +#define __pyx_n_u_dict_2 __pyx_string_tab[157] +#define __pyx_n_u_dict_3 __pyx_string_tab[158] +#define __pyx_n_u_dtype __pyx_string_tab[159] +#define __pyx_n_u_dtype_is_object __pyx_string_tab[160] +#define __pyx_n_u_dx __pyx_string_tab[161] +#define __pyx_n_u_dy __pyx_string_tab[162] +#define __pyx_n_u_encode __pyx_string_tab[163] +#define __pyx_n_u_enumerate __pyx_string_tab[164] +#define __pyx_n_u_error __pyx_string_tab[165] +#define __pyx_n_u_fill __pyx_string_tab[166] +#define __pyx_n_u_flags __pyx_string_tab[167] +#define __pyx_n_u_float __pyx_string_tab[168] +#define __pyx_n_u_format __pyx_string_tab[169] +#define __pyx_n_u_fortran __pyx_string_tab[170] +#define __pyx_n_u_func __pyx_string_tab[171] +#define __pyx_n_u_game_over __pyx_string_tab[172] +#define __pyx_n_u_genexpr __pyx_string_tab[173] +#define __pyx_n_u_get_action __pyx_string_tab[174] +#define __pyx_n_u_get_cell __pyx_string_tab[175] +#define __pyx_n_u_get_move __pyx_string_tab[176] +#define __pyx_n_u_get_occupied __pyx_string_tab[177] +#define __pyx_n_u_get_orientations __pyx_string_tab[178] +#define __pyx_n_u_get_piece __pyx_string_tab[179] +#define __pyx_n_u_get_piece_id __pyx_string_tab[180] +#define __pyx_n_u_get_player_corners __pyx_string_tab[181] +#define __pyx_n_u_get_player_occupied __pyx_string_tab[182] +#define __pyx_n_u_get_player_squares __pyx_string_tab[183] +#define __pyx_n_u_get_state __pyx_string_tab[184] +#define __pyx_n_u_get_valid_actions __pyx_string_tab[185] +#define __pyx_n_u_getstate __pyx_string_tab[186] +#define __pyx_n_u_grid_view __pyx_string_tab[187] +#define __pyx_n_u_has_overlap __pyx_string_tab[188] +#define __pyx_n_u_has_started __pyx_string_tab[189] +#define __pyx_n_u_has_valid_moves __pyx_string_tab[190] +#define __pyx_n_u_i __pyx_string_tab[191] +#define __pyx_n_u_id __pyx_string_tab[192] +#define __pyx_n_u_idx __pyx_string_tab[193] +#define __pyx_n_u_import __pyx_string_tab[194] +#define __pyx_n_u_in_bounds __pyx_string_tab[195] +#define __pyx_n_u_index __pyx_string_tab[196] +#define __pyx_n_u_init___locals_genexpr __pyx_string_tab[197] +#define __pyx_n_u_int __pyx_string_tab[198] +#define __pyx_n_u_int8 __pyx_string_tab[199] +#define __pyx_n_u_is_coroutine __pyx_string_tab[200] +#define __pyx_n_u_is_empty __pyx_string_tab[201] +#define __pyx_n_u_is_full __pyx_string_tab[202] +#define __pyx_n_u_items __pyx_string_tab[203] +#define __pyx_n_u_itemsize __pyx_string_tab[204] +#define __pyx_n_u_list __pyx_string_tab[205] +#define __pyx_n_u_main __pyx_string_tab[206] +#define __pyx_n_u_max __pyx_string_tab[207] +#define __pyx_n_u_memview __pyx_string_tab[208] +#define __pyx_n_u_min __pyx_string_tab[209] +#define __pyx_n_u_mode __pyx_string_tab[210] +#define __pyx_n_u_module __pyx_string_tab[211] +#define __pyx_n_u_move __pyx_string_tab[212] +#define __pyx_n_u_name __pyx_string_tab[213] +#define __pyx_n_u_name_2 __pyx_string_tab[214] +#define __pyx_n_u_ndim __pyx_string_tab[215] +#define __pyx_n_u_new __pyx_string_tab[216] +#define __pyx_n_u_new_game __pyx_string_tab[217] +#define __pyx_n_u_next __pyx_string_tab[218] +#define __pyx_n_u_next_idx __pyx_string_tab[219] +#define __pyx_n_u_next_player __pyx_string_tab[220] +#define __pyx_n_u_normalize_squares_cython_locals __pyx_string_tab[221] +#define __pyx_n_u_np __pyx_string_tab[222] +#define __pyx_n_u_num_actions __pyx_string_tab[223] +#define __pyx_n_u_num_pieces __pyx_string_tab[224] +#define __pyx_n_u_num_players __pyx_string_tab[225] +#define __pyx_n_u_numpy __pyx_string_tab[226] +#define __pyx_n_u_o __pyx_string_tab[227] +#define __pyx_n_u_obj __pyx_string_tab[228] +#define __pyx_n_u_offset __pyx_string_tab[229] +#define __pyx_n_u_orientation_id __pyx_string_tab[230] +#define __pyx_n_u_p __pyx_string_tab[231] +#define __pyx_n_u_pack __pyx_string_tab[232] +#define __pyx_n_u_piece __pyx_string_tab[233] +#define __pyx_n_u_piece_id __pyx_string_tab[234] +#define __pyx_n_u_pieces __pyx_string_tab[235] +#define __pyx_n_u_pieces_list __pyx_string_tab[236] +#define __pyx_n_u_place __pyx_string_tab[237] +#define __pyx_n_u_placed_corners __pyx_string_tab[238] +#define __pyx_n_u_placed_squares __pyx_string_tab[239] +#define __pyx_n_u_play_move __pyx_string_tab[240] +#define __pyx_n_u_player __pyx_string_tab[241] +#define __pyx_n_u_player_idx __pyx_string_tab[242] +#define __pyx_n_u_player_squares __pyx_string_tab[243] +#define __pyx_n_u_players __pyx_string_tab[244] +#define __pyx_n_u_pop __pyx_string_tab[245] +#define __pyx_n_u_pyx_checksum __pyx_string_tab[246] +#define __pyx_n_u_pyx_result __pyx_string_tab[247] +#define __pyx_n_u_pyx_state __pyx_string_tab[248] +#define __pyx_n_u_pyx_type __pyx_string_tab[249] +#define __pyx_n_u_pyx_unpickle_BlokusGame __pyx_string_tab[250] +#define __pyx_n_u_pyx_unpickle_Board __pyx_string_tab[251] +#define __pyx_n_u_pyx_unpickle_Enum __pyx_string_tab[252] +#define __pyx_n_u_pyx_unpickle_Move __pyx_string_tab[253] +#define __pyx_n_u_pyx_unpickle_Piece __pyx_string_tab[254] +#define __pyx_n_u_pyx_unpickle_PieceOrientation __pyx_string_tab[255] +#define __pyx_n_u_pyx_unpickle_PieceSet __pyx_string_tab[256] +#define __pyx_n_u_pyx_unpickle_PlayerState __pyx_string_tab[257] +#define __pyx_n_u_pyx_vtable __pyx_string_tab[258] +#define __pyx_n_u_qualname __pyx_string_tab[259] +#define __pyx_n_u_reduce __pyx_string_tab[260] +#define __pyx_n_u_reduce_cython __pyx_string_tab[261] +#define __pyx_n_u_reduce_ex __pyx_string_tab[262] +#define __pyx_n_u_register __pyx_string_tab[263] +#define __pyx_n_u_reset __pyx_string_tab[264] +#define __pyx_n_u_result __pyx_string_tab[265] +#define __pyx_n_u_return __pyx_string_tab[266] +#define __pyx_n_u_rounds __pyx_string_tab[267] +#define __pyx_n_u_score __pyx_string_tab[268] +#define __pyx_n_u_self __pyx_string_tab[269] +#define __pyx_n_u_send __pyx_string_tab[270] +#define __pyx_n_u_set __pyx_string_tab[271] +#define __pyx_n_u_set_name __pyx_string_tab[272] +#define __pyx_n_u_setdefault __pyx_string_tab[273] +#define __pyx_n_u_setstate __pyx_string_tab[274] +#define __pyx_n_u_setstate_cython __pyx_string_tab[275] +#define __pyx_n_u_shape __pyx_string_tab[276] +#define __pyx_n_u_size __pyx_string_tab[277] +#define __pyx_n_u_squares __pyx_string_tab[278] +#define __pyx_n_u_start __pyx_string_tab[279] +#define __pyx_n_u_state __pyx_string_tab[280] +#define __pyx_n_u_step __pyx_string_tab[281] +#define __pyx_n_u_stop __pyx_string_tab[282] +#define __pyx_n_u_struct __pyx_string_tab[283] +#define __pyx_n_u_sum __pyx_string_tab[284] +#define __pyx_n_u_test __pyx_string_tab[285] +#define __pyx_n_u_throw __pyx_string_tab[286] +#define __pyx_n_u_unpack __pyx_string_tab[287] +#define __pyx_n_u_update __pyx_string_tab[288] +#define __pyx_n_u_use_setstate __pyx_string_tab[289] +#define __pyx_n_u_valid_move __pyx_string_tab[290] +#define __pyx_n_u_value __pyx_string_tab[291] +#define __pyx_n_u_values __pyx_string_tab[292] +#define __pyx_n_u_x __pyx_string_tab[293] +#define __pyx_n_u_y __pyx_string_tab[294] +#define __pyx_n_u_zeros __pyx_string_tab[295] +#define __pyx_kp_b_iso88591_0_t __pyx_string_tab[296] +#define __pyx_kp_b_iso88591_1F __pyx_string_tab[297] +#define __pyx_kp_b_iso88591_1_a_4q_d_d_Q_q_1A_AQa_Qa_1A_E_Q __pyx_string_tab[298] +#define __pyx_kp_b_iso88591_1_a_A_CuA_uBc_U_b_4vS_S_1_q_q __pyx_string_tab[299] +#define __pyx_kp_b_iso88591_4A_a_A_1_E_aq_U_1_9AS_3a_3a_q __pyx_string_tab[300] +#define __pyx_kp_b_iso88591_4A_a_A_a_4_1_CuA_F_AT_d_q_5_1_E __pyx_string_tab[301] +#define __pyx_kp_b_iso88591_5Q_gT_s_47J_1_t_1A __pyx_string_tab[302] +#define __pyx_kp_b_iso88591_6 __pyx_string_tab[303] +#define __pyx_kp_b_iso88591_7q_1A_4t_a_1_1_Kq_A_q __pyx_string_tab[304] +#define __pyx_kp_b_iso88591_7q_haq_4z_1D_4_1A_F_Bc_xq_Q_j_Q __pyx_string_tab[305] +#define __pyx_kp_b_iso88591_A __pyx_string_tab[306] +#define __pyx_kp_b_iso88591_A_4q_4q_Je1Ct_Bhb_A_haq_D_AQ_a_q __pyx_string_tab[307] +#define __pyx_kp_b_iso88591_A_a_A_CuA_r_D_T_3d_U_c_Q_G1A __pyx_string_tab[308] +#define __pyx_kp_b_iso88591_A_haq_4z_1D_4_1A_4_1A_Kr_5_gV1_1 __pyx_string_tab[309] +#define __pyx_kp_b_iso88591_A_haq_6_Rq_HF_wat_1_4vQ_1_4v_T_q __pyx_string_tab[310] +#define __pyx_kp_b_iso88591_A_haq_HF_wat_1_4vQ_1_L_d_4AQ_4_t __pyx_string_tab[311] +#define __pyx_kp_b_iso88591_A_r_D_T_3d __pyx_string_tab[312] +#define __pyx_kp_b_iso88591_L_1D_t4_q_l_q_Q_Q __pyx_string_tab[313] +#define __pyx_kp_b_iso88591_T_4_0_Kt1_G1F_a_vWE_Q_q_t9G5_4y __pyx_string_tab[314] +#define __pyx_kp_b_iso88591_T_4wd_G1F_a_vWE_Q_q_t_G1_q_d_7 __pyx_string_tab[315] +#define __pyx_kp_b_iso88591_T_9_OtSggkkssw_x_E_E_I_I_W_W_l __pyx_string_tab[316] +#define __pyx_kp_b_iso88591_T_A_G1F_a_vWE_Q_q_t6_S_IWA_q_d __pyx_string_tab[317] +#define __pyx_kp_b_iso88591_T_D_4z_SWW_aab_G1F_a_vWE_Q_q_t __pyx_string_tab[318] +#define __pyx_kp_b_iso88591_T_D_t_n_a_G1F_a_vWE_Q_q_t_S_N_Q __pyx_string_tab[319] +#define __pyx_kp_b_iso88591_T_k_T_Q_G1F_a_vWE_Q_q_q_q_T_G1 __pyx_string_tab[320] +#define __pyx_kp_b_iso88591__11 __pyx_string_tab[321] +#define __pyx_kp_b_iso88591__9 __pyx_string_tab[322] +#define __pyx_kp_b_iso88591_a_A_2S_E_Rs_a_9AS_3a_q __pyx_string_tab[323] +#define __pyx_kp_b_iso88591_a_A_2S_E_Rs_a_9AS_q __pyx_string_tab[324] +#define __pyx_kp_b_iso88591_a_A_E_aq_U_1_9AS_3a_1_q __pyx_string_tab[325] +#define __pyx_kp_b_iso88591_a_A_E_aq_U_1_9AS_3a_Q_vS_Rq __pyx_string_tab[326] +#define __pyx_kp_b_iso88591_a_Q_t1_4q_A_A_V5_a_a_T_CuIQd_HA __pyx_string_tab[327] +#define __pyx_kp_b_iso88591_a_a_A_Q_E_aq_U_1_9AS_3a_b_1_q __pyx_string_tab[328] +#define __pyx_kp_b_iso88591_a_t __pyx_string_tab[329] +#define __pyx_kp_b_iso88591_avQ __pyx_string_tab[330] +#define __pyx_kp_b_iso88591_avQ_2 __pyx_string_tab[331] +#define __pyx_kp_b_iso88591_q __pyx_string_tab[332] +#define __pyx_kp_b_iso88591_q_0_kQR_4xq_7_awnA_1 __pyx_string_tab[333] +#define __pyx_kp_b_iso88591_q_0_kQR_5_7_q_a_1 __pyx_string_tab[334] +#define __pyx_kp_b_iso88591_q_0_kQR_81A_7_2_3FnTU_1 __pyx_string_tab[335] +#define __pyx_kp_b_iso88591_q_0_kQR_881A_7_nA_1 __pyx_string_tab[336] +#define __pyx_kp_b_iso88591_q_0_kQR_XQa_7_A_1 __pyx_string_tab[337] +#define __pyx_kp_b_iso88591_q_0_kQR_haq_7_QnN_1 __pyx_string_tab[338] +#define __pyx_kp_b_iso88591_q_2 __pyx_string_tab[339] +#define __pyx_kp_b_iso88591_q_3 __pyx_string_tab[340] +#define __pyx_kp_b_iso88591_q_4 __pyx_string_tab[341] +#define __pyx_kp_b_iso88591_q_E_aq __pyx_string_tab[342] +#define __pyx_kp_b_iso88591_q_IU_4q_Kq_a_Ja_M_E_at1_c_j_t_B __pyx_string_tab[343] +#define __pyx_kp_b_iso88591_q_t_2T_D8I_TQUUV __pyx_string_tab[344] +#define __pyx_kp_b_iso88591_t __pyx_string_tab[345] +#define __pyx_kp_b_iso88591_t7_1 __pyx_string_tab[346] +#define __pyx_n_b_O __pyx_string_tab[347] +#define __pyx_int_0 __pyx_number_tab[0] +#define __pyx_int_neg_1 __pyx_number_tab[1] +#define __pyx_int_1 __pyx_number_tab[2] +#define __pyx_int_2 __pyx_number_tab[3] +#define __pyx_int_3 __pyx_number_tab[4] +#define __pyx_int_4 __pyx_number_tab[5] +#define __pyx_int_5311788 __pyx_number_tab[6] +#define __pyx_int_10809183 __pyx_number_tab[7] +#define __pyx_int_48998121 __pyx_number_tab[8] +#define __pyx_int_72639080 __pyx_number_tab[9] +#define __pyx_int_136365258 __pyx_number_tab[10] +#define __pyx_int_136983863 __pyx_number_tab[11] +#define __pyx_int_189654061 __pyx_number_tab[12] +#define __pyx_int_260500659 __pyx_number_tab[13] +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __pyx_m_clear(PyObject *m) { + __pyx_mstatetype *clear_module_state = __Pyx_PyModule_GetState(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); + #if CYTHON_PEP489_MULTI_PHASE_INIT + __Pyx_State_RemoveModule(NULL); + #endif + Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4type_type); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_dtype); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_flatiter); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_broadcast); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_ndarray); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_generic); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_number); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_integer); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_signedinteger); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_unsignedinteger); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_inexact); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_floating); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_complexfloating); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_flexible); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_character); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_ufunc); + Py_CLEAR(clear_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board); + Py_CLEAR(clear_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython_Board); + Py_CLEAR(clear_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move); + Py_CLEAR(clear_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython_Move); + Py_CLEAR(clear_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation); + Py_CLEAR(clear_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython_PieceOrientation); + Py_CLEAR(clear_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece); + Py_CLEAR(clear_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython_Piece); + Py_CLEAR(clear_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet); + Py_CLEAR(clear_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython_PieceSet); + Py_CLEAR(clear_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState); + Py_CLEAR(clear_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython_PlayerState); + Py_CLEAR(clear_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame); + Py_CLEAR(clear_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython_BlokusGame); + Py_CLEAR(clear_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr); + Py_CLEAR(clear_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr); + Py_CLEAR(clear_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr); + Py_CLEAR(clear_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr); + Py_CLEAR(clear_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr); + Py_CLEAR(clear_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr); + Py_CLEAR(clear_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr); + Py_CLEAR(clear_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr); + Py_CLEAR(clear_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr); + Py_CLEAR(clear_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr); + Py_CLEAR(clear_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr); + Py_CLEAR(clear_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr); + Py_CLEAR(clear_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr); + Py_CLEAR(clear_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr); + Py_CLEAR(clear_module_state->__pyx_array_type); + Py_CLEAR(clear_module_state->__pyx_type___pyx_array); + Py_CLEAR(clear_module_state->__pyx_MemviewEnum_type); + Py_CLEAR(clear_module_state->__pyx_type___pyx_MemviewEnum); + Py_CLEAR(clear_module_state->__pyx_memoryview_type); + Py_CLEAR(clear_module_state->__pyx_type___pyx_memoryview); + Py_CLEAR(clear_module_state->__pyx_memoryviewslice_type); + Py_CLEAR(clear_module_state->__pyx_type___pyx_memoryviewslice); + for (int i=0; i<1; ++i) { Py_CLEAR(clear_module_state->__pyx_slice[i]); } + for (int i=0; i<41; ++i) { Py_CLEAR(clear_module_state->__pyx_tuple[i]); } + for (int i=0; i<55; ++i) { Py_CLEAR(clear_module_state->__pyx_codeobj_tab[i]); } + for (int i=0; i<348; ++i) { Py_CLEAR(clear_module_state->__pyx_string_tab[i]); } + for (int i=0; i<14; ++i) { Py_CLEAR(clear_module_state->__pyx_number_tab[i]); } +/* #### Code section: module_state_clear_contents ### */ +/* CommonTypesMetaclass.module_state_clear */ +Py_CLEAR(clear_module_state->__pyx_CommonTypesMetaclassType); + +/* CythonFunctionShared.module_state_clear */ +Py_CLEAR(clear_module_state->__pyx_CyFunctionType); + +/* Generator.module_state_clear */ +Py_CLEAR(clear_module_state->__pyx_GeneratorType); + +/* #### Code section: module_state_clear_end ### */ +return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstatetype *traverse_module_state = __Pyx_PyModule_GetState(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_tuple); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_bytes); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_unicode); + Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_4type_type); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_dtype); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_flatiter); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_broadcast); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_ndarray); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_generic); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_number); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_integer); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_signedinteger); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_unsignedinteger); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_inexact); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_floating); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_complexfloating); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_flexible); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_character); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_ufunc); + Py_VISIT(traverse_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board); + Py_VISIT(traverse_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython_Board); + Py_VISIT(traverse_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move); + Py_VISIT(traverse_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython_Move); + Py_VISIT(traverse_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation); + Py_VISIT(traverse_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython_PieceOrientation); + Py_VISIT(traverse_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece); + Py_VISIT(traverse_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython_Piece); + Py_VISIT(traverse_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet); + Py_VISIT(traverse_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython_PieceSet); + Py_VISIT(traverse_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState); + Py_VISIT(traverse_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython_PlayerState); + Py_VISIT(traverse_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame); + Py_VISIT(traverse_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython_BlokusGame); + Py_VISIT(traverse_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr); + Py_VISIT(traverse_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr); + Py_VISIT(traverse_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr); + Py_VISIT(traverse_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr); + Py_VISIT(traverse_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr); + Py_VISIT(traverse_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr); + Py_VISIT(traverse_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr); + Py_VISIT(traverse_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr); + Py_VISIT(traverse_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr); + Py_VISIT(traverse_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr); + Py_VISIT(traverse_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr); + Py_VISIT(traverse_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr); + Py_VISIT(traverse_module_state->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr); + Py_VISIT(traverse_module_state->__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr); + Py_VISIT(traverse_module_state->__pyx_array_type); + Py_VISIT(traverse_module_state->__pyx_type___pyx_array); + Py_VISIT(traverse_module_state->__pyx_MemviewEnum_type); + Py_VISIT(traverse_module_state->__pyx_type___pyx_MemviewEnum); + Py_VISIT(traverse_module_state->__pyx_memoryview_type); + Py_VISIT(traverse_module_state->__pyx_type___pyx_memoryview); + Py_VISIT(traverse_module_state->__pyx_memoryviewslice_type); + Py_VISIT(traverse_module_state->__pyx_type___pyx_memoryviewslice); + for (int i=0; i<1; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_slice[i]); } + for (int i=0; i<41; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_tuple[i]); } + for (int i=0; i<55; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_codeobj_tab[i]); } + for (int i=0; i<348; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_string_tab[i]); } + for (int i=0; i<14; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_number_tab[i]); } +/* #### Code section: module_state_traverse_contents ### */ +/* CommonTypesMetaclass.module_state_traverse */ +Py_VISIT(traverse_module_state->__pyx_CommonTypesMetaclassType); + +/* CythonFunctionShared.module_state_traverse */ +Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + +/* Generator.module_state_traverse */ +Py_VISIT(traverse_module_state->__pyx_GeneratorType); + +/* #### Code section: module_state_traverse_end ### */ +return 0; +} +#endif +/* #### Code section: module_code ### */ + +/* "View.MemoryView":137 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): + * +*/ + +/* Python wrapper */ +static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_shape = 0; + Py_ssize_t __pyx_v_itemsize; + PyObject *__pyx_v_format = 0; + PyObject *__pyx_v_mode = 0; + int __pyx_v_allocate_buffer; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[5] = {0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_shape,&__pyx_mstate_global->__pyx_n_u_itemsize,&__pyx_mstate_global->__pyx_n_u_format,&__pyx_mstate_global->__pyx_n_u_mode,&__pyx_mstate_global->__pyx_n_u_allocate_buffer,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 137, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 5: + values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(1, 137, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(1, 137, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 137, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 137, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 137, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__cinit__", 0) < (0)) __PYX_ERR(1, 137, __pyx_L3_error) + if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_n_u_c)); + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, i); __PYX_ERR(1, 137, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 5: + values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(1, 137, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(1, 137, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 137, __pyx_L3_error) + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 137, __pyx_L3_error) + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 137, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_n_u_c)); + } + __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, 137, __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, 138, __pyx_L3_error) + } else { + + /* "View.MemoryView":138 + * + * 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_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, __pyx_nargs); __PYX_ERR(1, 137, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __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, 137, __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, 137, __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":137 + * 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; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer) { + int __pyx_v_idx; + Py_ssize_t __pyx_v_dim; + char __pyx_v_order; + int __pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + char *__pyx_t_7; + int __pyx_t_8; + Py_ssize_t __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11[5]; + PyObject *__pyx_t_12 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + __Pyx_INCREF(__pyx_v_format); + + /* "View.MemoryView":143 + * cdef Py_ssize_t dim + * + * self.ndim = len(shape) # <<<<<<<<<<<<<< + * self.itemsize = itemsize + * +*/ + if (unlikely(__pyx_v_shape == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 143, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 143, __pyx_L1_error) + __pyx_v_self->ndim = ((int)__pyx_t_1); + + /* "View.MemoryView":144 + * + * self.ndim = len(shape) + * self.itemsize = itemsize # <<<<<<<<<<<<<< + * + * if not self.ndim: +*/ + __pyx_v_self->itemsize = __pyx_v_itemsize; + + /* "View.MemoryView":146 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError, "Empty shape tuple for cython.array" + * +*/ + __pyx_t_2 = (!(__pyx_v_self->ndim != 0)); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":147 + * + * if not self.ndim: + * raise ValueError, "Empty shape tuple for cython.array" # <<<<<<<<<<<<<< + * + * if itemsize <= 0: +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_ValueError))), __pyx_mstate_global->__pyx_kp_u_Empty_shape_tuple_for_cython_arr, 0, 0); + __PYX_ERR(1, 147, __pyx_L1_error) + + /* "View.MemoryView":146 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError, "Empty shape tuple for cython.array" + * +*/ + } + + /* "View.MemoryView":149 + * raise ValueError, "Empty shape tuple for cython.array" + * + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError, "itemsize <= 0 for cython.array" + * +*/ + __pyx_t_2 = (__pyx_v_itemsize <= 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":150 + * + * if itemsize <= 0: + * raise ValueError, "itemsize <= 0 for cython.array" # <<<<<<<<<<<<<< + * + * if not isinstance(format, bytes): +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_ValueError))), __pyx_mstate_global->__pyx_kp_u_itemsize_0_for_cython_array, 0, 0); + __PYX_ERR(1, 150, __pyx_L1_error) + + /* "View.MemoryView":149 + * raise ValueError, "Empty shape tuple for cython.array" + * + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError, "itemsize <= 0 for cython.array" + * +*/ + } + + /* "View.MemoryView":152 + * raise ValueError, "itemsize <= 0 for cython.array" + * + * if not isinstance(format, bytes): # <<<<<<<<<<<<<< + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string +*/ + __pyx_t_2 = PyBytes_Check(__pyx_v_format); + __pyx_t_3 = (!__pyx_t_2); + if (__pyx_t_3) { + + /* "View.MemoryView":153 + * + * 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_v_format; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ASCII}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_encode, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":152 + * 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":154 + * 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_4 = __pyx_v_format; + __Pyx_INCREF(__pyx_t_4); + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_4))) __PYX_ERR(1, 154, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_v_self->_format); + __Pyx_DECREF(__pyx_v_self->_format); + __pyx_v_self->_format = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":155 + * 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, 155, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(1, 155, __pyx_L1_error) + __pyx_v_self->format = __pyx_t_7; + + /* "View.MemoryView":158 + * + * + * 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":159 + * + * 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":161 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError, "unable to allocate shape and strides." + * +*/ + __pyx_t_3 = (!(__pyx_v_self->_shape != 0)); + if (unlikely(__pyx_t_3)) { + + /* "View.MemoryView":162 + * + * if not self._shape: + * raise MemoryError, "unable to allocate shape and strides." # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_MemoryError))), __pyx_mstate_global->__pyx_kp_u_unable_to_allocate_shape_and_str, 0, 0); + __PYX_ERR(1, 162, __pyx_L1_error) + + /* "View.MemoryView":161 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError, "unable to allocate shape and strides." + * +*/ + } + + /* "View.MemoryView":165 + * + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError, f"Invalid shape in axis {idx}: {dim}." +*/ + __pyx_t_8 = 0; + __pyx_t_4 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_4); + __pyx_t_1 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 165, __pyx_L1_error) + #endif + if (__pyx_t_1 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_1)); + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_1); + #endif + ++__pyx_t_1; + if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 165, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 165, __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":166 + * + * for idx, dim in enumerate(shape): + * if dim <= 0: # <<<<<<<<<<<<<< + * raise ValueError, f"Invalid shape in axis {idx}: {dim}." + * self._shape[idx] = dim +*/ + __pyx_t_3 = (__pyx_v_dim <= 0); + if (unlikely(__pyx_t_3)) { + + /* "View.MemoryView":167 + * for idx, dim in enumerate(shape): + * if dim <= 0: + * raise ValueError, f"Invalid shape in axis {idx}: {dim}." # <<<<<<<<<<<<<< + * self._shape[idx] = dim + * +*/ + __pyx_t_5 = __Pyx_PyUnicode_From_int(__pyx_v_idx, 0, ' ', 'd'); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_10 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_shape_in_axis; + __pyx_t_11[1] = __pyx_t_5; + __pyx_t_11[2] = __pyx_mstate_global->__pyx_kp_u_; + __pyx_t_11[3] = __pyx_t_10; + __pyx_t_11[4] = __pyx_mstate_global->__pyx_kp_u__2; + __pyx_t_12 = __Pyx_PyUnicode_Join(__pyx_t_11, 5, 22 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10) + 1, 127); + if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 167, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_ValueError))), __pyx_t_12, 0, 0); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __PYX_ERR(1, 167, __pyx_L1_error) + + /* "View.MemoryView":166 + * + * for idx, dim in enumerate(shape): + * if dim <= 0: # <<<<<<<<<<<<<< + * raise ValueError, f"Invalid shape in axis {idx}: {dim}." + * self._shape[idx] = dim +*/ + } + + /* "View.MemoryView":168 + * if dim <= 0: + * raise ValueError, f"Invalid shape in axis {idx}: {dim}." + * self._shape[idx] = dim # <<<<<<<<<<<<<< + * + * cdef char order +*/ + (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim; + + /* "View.MemoryView":165 + * + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError, f"Invalid shape in axis {idx}: {dim}." +*/ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":171 + * + * cdef char order + * if mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' +*/ + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_mode, __pyx_mstate_global->__pyx_n_u_c, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 171, __pyx_L1_error) + if (__pyx_t_3) { + + /* "View.MemoryView":172 + * cdef char order + * if mode == 'c': + * order = b'C' # <<<<<<<<<<<<<< + * self.mode = u'c' + * elif mode == 'fortran': +*/ + __pyx_v_order = 'C'; + + /* "View.MemoryView":173 + * if mode == 'c': + * order = b'C' + * self.mode = u'c' # <<<<<<<<<<<<<< + * elif mode == 'fortran': + * order = b'F' +*/ + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_c); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_c); + __Pyx_GOTREF(__pyx_v_self->mode); + __Pyx_DECREF(__pyx_v_self->mode); + __pyx_v_self->mode = __pyx_mstate_global->__pyx_n_u_c; + + /* "View.MemoryView":171 + * + * cdef char order + * if mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' +*/ + goto __pyx_L11; + } + + /* "View.MemoryView":174 + * order = b'C' + * self.mode = u'c' + * elif mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' +*/ + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_mode, __pyx_mstate_global->__pyx_n_u_fortran, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 174, __pyx_L1_error) + if (likely(__pyx_t_3)) { + + /* "View.MemoryView":175 + * self.mode = u'c' + * elif mode == 'fortran': + * order = b'F' # <<<<<<<<<<<<<< + * self.mode = u'fortran' + * else: +*/ + __pyx_v_order = 'F'; + + /* "View.MemoryView":176 + * elif mode == 'fortran': + * order = b'F' + * self.mode = u'fortran' # <<<<<<<<<<<<<< + * else: + * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" +*/ + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_fortran); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_fortran); + __Pyx_GOTREF(__pyx_v_self->mode); + __Pyx_DECREF(__pyx_v_self->mode); + __pyx_v_self->mode = __pyx_mstate_global->__pyx_n_u_fortran; + + /* "View.MemoryView":174 + * order = b'C' + * self.mode = u'c' + * elif mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' +*/ + goto __pyx_L11; + } + + /* "View.MemoryView":178 + * self.mode = u'fortran' + * else: + * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" # <<<<<<<<<<<<<< + * + * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) +*/ + /*else*/ { + __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_mode, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Invalid_mode_expected_c_or_fortr, __pyx_t_4); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_ValueError))), __pyx_t_12, 0, 0); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __PYX_ERR(1, 178, __pyx_L1_error) + } + __pyx_L11:; + + /* "View.MemoryView":180 + * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" + * + * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) # <<<<<<<<<<<<<< + * + * self.free_data = allocate_buffer +*/ + __pyx_v_self->len = __pyx_fill_contig_strides_array(__pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_itemsize, __pyx_v_self->ndim, __pyx_v_order); + + /* "View.MemoryView":182 + * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) + * + * self.free_data = allocate_buffer # <<<<<<<<<<<<<< + * self.dtype_is_object = format == b'O' + * +*/ + __pyx_v_self->free_data = __pyx_v_allocate_buffer; + + /* "View.MemoryView":183 + * + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<< + * + * if allocate_buffer: +*/ + __pyx_t_12 = PyObject_RichCompare(__pyx_v_format, __pyx_mstate_global->__pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_12); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 183, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_12); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 183, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_v_self->dtype_is_object = __pyx_t_3; + + /* "View.MemoryView":185 + * self.dtype_is_object = format == b'O' + * + * if allocate_buffer: # <<<<<<<<<<<<<< + * _allocate_buffer(self) + * +*/ + if (__pyx_v_allocate_buffer) { + + /* "View.MemoryView":186 + * + * if allocate_buffer: + * _allocate_buffer(self) # <<<<<<<<<<<<<< + * + * @cname('getbuffer') +*/ + __pyx_t_8 = __pyx_array_allocate_buffer(__pyx_v_self); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(1, 186, __pyx_L1_error) + + /* "View.MemoryView":185 + * self.dtype_is_object = format == b'O' + * + * if allocate_buffer: # <<<<<<<<<<<<<< + * _allocate_buffer(self) + * +*/ + } + + /* "View.MemoryView":137 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): + * +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_12); + __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":188 + * _allocate_buffer(self) + * + * @cname('getbuffer') # <<<<<<<<<<<<<< + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 +*/ + +/* Python wrapper */ +CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(((struct __pyx_array_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_bufmode; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + char *__pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + Py_ssize_t *__pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + if (unlikely(__pyx_v_info == NULL)) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + + /* "View.MemoryView":190 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 # <<<<<<<<<<<<<< + * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): + * if self.mode == u"c": +*/ + __pyx_v_bufmode = -1; + + /* "View.MemoryView":191 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): # <<<<<<<<<<<<<< + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS +*/ + __pyx_t_1 = ((__pyx_v_flags & ((PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS) | PyBUF_ANY_CONTIGUOUS)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":192 + * cdef int bufmode = -1 + * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": +*/ + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_mstate_global->__pyx_n_u_c, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 192, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":193 + * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS +*/ + __pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); + + /* "View.MemoryView":192 + * cdef int bufmode = -1 + * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": +*/ + goto __pyx_L4; + } + + /* "View.MemoryView":194 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": # <<<<<<<<<<<<<< + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): +*/ + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_mstate_global->__pyx_n_u_fortran, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 194, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":195 + * 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":194 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": # <<<<<<<<<<<<<< + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): +*/ + } + __pyx_L4:; + + /* "View.MemoryView":196 + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): # <<<<<<<<<<<<<< + * raise ValueError, "Can only create a buffer that is contiguous in memory." + * info.buf = self.data +*/ + __pyx_t_1 = (!((__pyx_v_flags & __pyx_v_bufmode) != 0)); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":197 + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + * raise ValueError, "Can only create a buffer that is contiguous in memory." # <<<<<<<<<<<<<< + * info.buf = self.data + * info.len = self.len +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_ValueError))), __pyx_mstate_global->__pyx_kp_u_Can_only_create_a_buffer_that_is, 0, 0); + __PYX_ERR(1, 197, __pyx_L1_error) + + /* "View.MemoryView":196 + * 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":191 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): # <<<<<<<<<<<<<< + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS +*/ + } + + /* "View.MemoryView":198 + * if not (flags & bufmode): + * raise ValueError, "Can only create a buffer that is contiguous in memory." + * info.buf = self.data # <<<<<<<<<<<<<< + * info.len = self.len + * +*/ + __pyx_t_2 = __pyx_v_self->data; + __pyx_v_info->buf = __pyx_t_2; + + /* "View.MemoryView":199 + * raise ValueError, "Can only create a buffer that is contiguous in memory." + * info.buf = self.data + * info.len = self.len # <<<<<<<<<<<<<< + * + * if flags & PyBUF_STRIDES: +*/ + __pyx_t_3 = __pyx_v_self->len; + __pyx_v_info->len = __pyx_t_3; + + /* "View.MemoryView":201 + * info.len = self.len + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.ndim = self.ndim + * info.shape = self._shape +*/ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":202 + * + * if flags & PyBUF_STRIDES: + * info.ndim = self.ndim # <<<<<<<<<<<<<< + * info.shape = self._shape + * info.strides = self._strides +*/ + __pyx_t_4 = __pyx_v_self->ndim; + __pyx_v_info->ndim = __pyx_t_4; + + /* "View.MemoryView":203 + * if flags & PyBUF_STRIDES: + * info.ndim = self.ndim + * info.shape = self._shape # <<<<<<<<<<<<<< + * info.strides = self._strides + * else: +*/ + __pyx_t_5 = __pyx_v_self->_shape; + __pyx_v_info->shape = __pyx_t_5; + + /* "View.MemoryView":204 + * info.ndim = self.ndim + * info.shape = self._shape + * info.strides = self._strides # <<<<<<<<<<<<<< + * else: + * info.ndim = 1 +*/ + __pyx_t_5 = __pyx_v_self->_strides; + __pyx_v_info->strides = __pyx_t_5; + + /* "View.MemoryView":201 + * info.len = self.len + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.ndim = self.ndim + * info.shape = self._shape +*/ + goto __pyx_L6; + } + + /* "View.MemoryView":206 + * info.strides = self._strides + * else: + * info.ndim = 1 # <<<<<<<<<<<<<< + * info.shape = &self.len if flags & PyBUF_ND else NULL + * info.strides = NULL +*/ + /*else*/ { + __pyx_v_info->ndim = 1; + + /* "View.MemoryView":207 + * else: + * info.ndim = 1 + * info.shape = &self.len if flags & PyBUF_ND else NULL # <<<<<<<<<<<<<< + * info.strides = NULL + * +*/ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0); + if (__pyx_t_1) { + __pyx_t_5 = (&__pyx_v_self->len); + } else { + __pyx_t_5 = NULL; + } + __pyx_v_info->shape = __pyx_t_5; + + /* "View.MemoryView":208 + * info.ndim = 1 + * info.shape = &self.len if flags & PyBUF_ND else NULL + * info.strides = NULL # <<<<<<<<<<<<<< + * + * info.suboffsets = NULL +*/ + __pyx_v_info->strides = NULL; + } + __pyx_L6:; + + /* "View.MemoryView":210 + * info.strides = NULL + * + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = self.itemsize + * info.readonly = 0 +*/ + __pyx_v_info->suboffsets = NULL; + + /* "View.MemoryView":211 + * + * info.suboffsets = NULL + * info.itemsize = self.itemsize # <<<<<<<<<<<<<< + * info.readonly = 0 + * info.format = self.format if flags & PyBUF_FORMAT else NULL +*/ + __pyx_t_3 = __pyx_v_self->itemsize; + __pyx_v_info->itemsize = __pyx_t_3; + + /* "View.MemoryView":212 + * info.suboffsets = NULL + * info.itemsize = self.itemsize + * info.readonly = 0 # <<<<<<<<<<<<<< + * info.format = self.format if flags & PyBUF_FORMAT else NULL + * info.obj = self +*/ + __pyx_v_info->readonly = 0; + + /* "View.MemoryView":213 + * info.itemsize = self.itemsize + * info.readonly = 0 + * info.format = self.format if flags & PyBUF_FORMAT else NULL # <<<<<<<<<<<<<< + * info.obj = self + * +*/ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + __pyx_t_2 = __pyx_v_self->format; + } else { + __pyx_t_2 = NULL; + } + __pyx_v_info->format = __pyx_t_2; + + /* "View.MemoryView":214 + * info.readonly = 0 + * info.format = self.format if flags & PyBUF_FORMAT else NULL + * info.obj = self # <<<<<<<<<<<<<< + * + * def __dealloc__(array self): +*/ + __Pyx_INCREF((PyObject *)__pyx_v_self); + __Pyx_GIVEREF((PyObject *)__pyx_v_self); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + + /* "View.MemoryView":188 + * _allocate_buffer(self) + * + * @cname('getbuffer') # <<<<<<<<<<<<<< + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.array.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":216 + * info.obj = self + * + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) +*/ + +/* Python wrapper */ +static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_array___dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) { + int __pyx_t_1; + int __pyx_t_2; + + /* "View.MemoryView":217 + * + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data and self.data is not NULL: +*/ + __pyx_t_1 = (__pyx_v_self->callback_free_data != NULL); + if (__pyx_t_1) { + + /* "View.MemoryView":218 + * def __dealloc__(array self): + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) # <<<<<<<<<<<<<< + * elif self.free_data and self.data is not NULL: + * if self.dtype_is_object: +*/ + __pyx_v_self->callback_free_data(__pyx_v_self->data); + + /* "View.MemoryView":217 + * + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data and self.data is not NULL: +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":219 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data and self.data is not NULL: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) +*/ + if (__pyx_v_self->free_data) { + } else { + __pyx_t_1 = __pyx_v_self->free_data; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_self->data != NULL); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "View.MemoryView":220 + * self.callback_free_data(self.data) + * elif self.free_data and self.data is not NULL: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) + * free(self.data) +*/ + if (__pyx_v_self->dtype_is_object) { + + /* "View.MemoryView":221 + * elif self.free_data and self.data is not NULL: + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) # <<<<<<<<<<<<<< + * free(self.data) + * PyObject_Free(self._shape) +*/ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_self->data, __pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_self->ndim, 0); + + /* "View.MemoryView":220 + * self.callback_free_data(self.data) + * elif self.free_data and self.data is not NULL: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) + * free(self.data) +*/ + } + + /* "View.MemoryView":222 + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) + * free(self.data) # <<<<<<<<<<<<<< + * PyObject_Free(self._shape) + * +*/ + free(__pyx_v_self->data); + + /* "View.MemoryView":219 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data and self.data is not NULL: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) +*/ + } + __pyx_L3:; + + /* "View.MemoryView":223 + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) + * free(self.data) + * PyObject_Free(self._shape) # <<<<<<<<<<<<<< + * + * @property +*/ + PyObject_Free(__pyx_v_self->_shape); + + /* "View.MemoryView":216 + * info.obj = self + * + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) +*/ + + /* function exit code */ +} + +/* "View.MemoryView":225 + * PyObject_Free(self._shape) + * + * @property # <<<<<<<<<<<<<< + * def memview(self): + * return self.get_memview() +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_15View_dot_MemoryView_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":227 + * @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, 227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":225 + * PyObject_Free(self._shape) + * + * @property # <<<<<<<<<<<<<< + * def memview(self): + * return self.get_memview() +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.memview.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":229 + * return self.get_memview() + * + * @cname('get_memview') # <<<<<<<<<<<<<< + * cdef get_memview(self): + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE +*/ + +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; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_memview", 0); + + /* "View.MemoryView":231 + * @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":232 + * 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_2 = NULL; + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 232, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[4] = {__pyx_t_2, ((PyObject *)__pyx_v_self), __pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_memoryview_type, __pyx_callargs+__pyx_t_5, (4-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 232, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + } + __pyx_r = ((PyObject *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":229 + * return self.get_memview() + * + * @cname('get_memview') # <<<<<<<<<<<<<< + * cdef get_memview(self): + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE +*/ + + /* 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.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":234 + * return memoryview(self, flags, self.dtype_is_object) + * + * def __len__(self): # <<<<<<<<<<<<<< + * return self._shape[0] + * +*/ + +/* Python wrapper */ +static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self); /*proto*/ +static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* 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; + + /* "View.MemoryView":235 + * + * def __len__(self): + * return self._shape[0] # <<<<<<<<<<<<<< + * + * def __getattr__(self, attr): +*/ + __pyx_r = (__pyx_v_self->_shape[0]); + goto __pyx_L0; + + /* "View.MemoryView":234 + * return memoryview(self, flags, self.dtype_is_object) + * + * def __len__(self): # <<<<<<<<<<<<<< + * return self._shape[0] + * +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":237 + * return self._shape[0] + * + * def __getattr__(self, attr): # <<<<<<<<<<<<<< + * return getattr(self.memview, attr) + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr); /*proto*/ +static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_attr)); + + /* 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":238 + * + * 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_mstate_global->__pyx_n_u_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 238, __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, 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 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":240 + * return getattr(self.memview, attr) + * + * def __getitem__(self, item): # <<<<<<<<<<<<<< + * return self.memview[item] + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/ +static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static 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":241 + * + * 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_mstate_global->__pyx_n_u_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 241, __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, 241, __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":240 + * 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":243 + * return self.memview[item] + * + * def __setitem__(self, item, value): # <<<<<<<<<<<<<< + * self.memview[item] = value + * +*/ + +/* Python wrapper */ +static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static 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":244 + * + * def __setitem__(self, item, value): + * self.memview[item] = value # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 244, __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, 244, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":243 + * return self.memview[item] + * + * def __setitem__(self, item, value): # <<<<<<<<<<<<<< + * self.memview[item] = value + * +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.array.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 3, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(1, 3, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 3, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf___pyx_array_2__setstate_cython__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":253 + * pass + * + * @cname("__pyx_array_allocate_buffer") # <<<<<<<<<<<<<< + * cdef int _allocate_buffer(array self) except -1: + * +*/ + +static int __pyx_array_allocate_buffer(struct __pyx_array_obj *__pyx_v_self) { + Py_ssize_t __pyx_v_i; + PyObject **__pyx_v_p; + int __pyx_r; + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":260 + * cdef PyObject **p + * + * self.free_data = True # <<<<<<<<<<<<<< + * self.data = malloc(self.len) + * if not self.data: +*/ + __pyx_v_self->free_data = 1; + + /* "View.MemoryView":261 + * + * self.free_data = True + * self.data = malloc(self.len) # <<<<<<<<<<<<<< + * if not self.data: + * raise MemoryError, "unable to allocate array data." +*/ + __pyx_v_self->data = ((char *)malloc(__pyx_v_self->len)); + + /* "View.MemoryView":262 + * self.free_data = True + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError, "unable to allocate array data." + * +*/ + __pyx_t_1 = (!(__pyx_v_self->data != 0)); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":263 + * self.data = malloc(self.len) + * if not self.data: + * raise MemoryError, "unable to allocate array data." # <<<<<<<<<<<<<< + * + * if self.dtype_is_object: +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_MemoryError))), __pyx_mstate_global->__pyx_kp_u_unable_to_allocate_array_data, 0, 0); + __PYX_ERR(1, 263, __pyx_L1_error) + + /* "View.MemoryView":262 + * self.free_data = True + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError, "unable to allocate array data." + * +*/ + } + + /* "View.MemoryView":265 + * raise MemoryError, "unable to allocate array data." + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len // self.itemsize): +*/ + if (__pyx_v_self->dtype_is_object) { + + /* "View.MemoryView":266 + * + * if self.dtype_is_object: + * p = self.data # <<<<<<<<<<<<<< + * for i in range(self.len // self.itemsize): + * p[i] = Py_None +*/ + __pyx_v_p = ((PyObject **)__pyx_v_self->data); + + /* "View.MemoryView":267 + * if self.dtype_is_object: + * p = self.data + * for i in range(self.len // self.itemsize): # <<<<<<<<<<<<<< + * p[i] = Py_None + * Py_INCREF(Py_None) +*/ + if (unlikely(__pyx_v_self->itemsize == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); + __PYX_ERR(1, 267, __pyx_L1_error) + } + else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_self->itemsize == (Py_ssize_t)-1) && unlikely(__Pyx_UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) { + PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); + __PYX_ERR(1, 267, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_self->itemsize, 0); + __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":268 + * p = self.data + * for i in range(self.len // self.itemsize): + * p[i] = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * return 0 +*/ + (__pyx_v_p[__pyx_v_i]) = Py_None; + + /* "View.MemoryView":269 + * for i in range(self.len // self.itemsize): + * p[i] = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * return 0 + * +*/ + Py_INCREF(Py_None); + } + + /* "View.MemoryView":265 + * raise MemoryError, "unable to allocate array data." + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len // self.itemsize): +*/ + } + + /* "View.MemoryView":270 + * p[i] = Py_None + * Py_INCREF(Py_None) + * return 0 # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":253 + * pass + * + * @cname("__pyx_array_allocate_buffer") # <<<<<<<<<<<<<< + * cdef int _allocate_buffer(array self) except -1: + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView._allocate_buffer", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":273 + * + * + * @cname("__pyx_array_new") # <<<<<<<<<<<<<< + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, const char *c_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 const *__pyx_v_c_mode, char *__pyx_v_buf) { + struct __pyx_array_obj *__pyx_v_result = 0; + PyObject *__pyx_v_mode = 0; + struct __pyx_array_obj *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("array_cwrapper", 0); + + /* "View.MemoryView":276 + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, const char *c_mode, char *buf): + * cdef array result + * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. # <<<<<<<<<<<<<< + * + * if buf is NULL: +*/ + __pyx_t_2 = ((__pyx_v_c_mode[0]) == 'f'); + if (__pyx_t_2) { + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_fortran); + __pyx_t_1 = __pyx_mstate_global->__pyx_n_u_fortran; + } else { + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_c); + __pyx_t_1 = __pyx_mstate_global->__pyx_n_u_c; + } + __pyx_v_mode = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":278 + * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. + * + * if buf is NULL: # <<<<<<<<<<<<<< + * result = array.__new__(array, shape, itemsize, format, mode) + * else: +*/ + __pyx_t_2 = (__pyx_v_buf == NULL); + if (__pyx_t_2) { + + /* "View.MemoryView":279 + * + * if buf is NULL: + * result = array.__new__(array, shape, itemsize, format, mode) # <<<<<<<<<<<<<< + * else: + * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) +*/ + __pyx_t_1 = PyLong_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 279, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 279, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 279, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_shape); + __Pyx_GIVEREF(__pyx_v_shape); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_shape) != (0)) __PYX_ERR(1, 279, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 279, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3) != (0)) __PYX_ERR(1, 279, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_mode); + __Pyx_GIVEREF(__pyx_v_mode); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_v_mode) != (0)) __PYX_ERR(1, 279, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_3 = 0; + __pyx_t_3 = ((PyObject *)__pyx_tp_new_array(((PyTypeObject *)__pyx_mstate_global->__pyx_array_type), __pyx_t_4, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 279, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":278 + * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. + * + * if buf is NULL: # <<<<<<<<<<<<<< + * result = array.__new__(array, shape, itemsize, format, mode) + * else: +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":281 + * result = array.__new__(array, shape, itemsize, format, mode) + * else: + * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) # <<<<<<<<<<<<<< + * result.data = buf + * +*/ + /*else*/ { + __pyx_t_3 = PyLong_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_shape); + __Pyx_GIVEREF(__pyx_v_shape); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_shape) != (0)) __PYX_ERR(1, 281, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3) != (0)) __PYX_ERR(1, 281, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_t_4) != (0)) __PYX_ERR(1, 281, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_mode); + __Pyx_GIVEREF(__pyx_v_mode); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_v_mode) != (0)) __PYX_ERR(1, 281, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_allocate_buffer, Py_False) < (0)) __PYX_ERR(1, 281, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_tp_new_array(((PyTypeObject *)__pyx_mstate_global->__pyx_array_type), __pyx_t_1, __pyx_t_4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 281, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":282 + * else: + * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) + * result.data = buf # <<<<<<<<<<<<<< + * + * return result +*/ + __pyx_v_result->data = __pyx_v_buf; + } + __pyx_L3:; + + /* "View.MemoryView":284 + * 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":273 + * + * + * @cname("__pyx_array_new") # <<<<<<<<<<<<<< + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, const char *c_mode, char *buf): + * cdef array result +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XDECREF(__pyx_v_mode); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":310 + * cdef class Enum(object): + * cdef object name + * def __init__(self, name): # <<<<<<<<<<<<<< + * self.name = name + * def __repr__(self): +*/ + +/* Python wrapper */ +static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_name = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_name,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 310, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 310, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < (0)) __PYX_ERR(1, 310, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, i); __PYX_ERR(1, 310, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 310, __pyx_L3_error) + } + __pyx_v_name = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 310, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __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 */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __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":311 + * 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":310 + * 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":312 + * def __init__(self, name): + * self.name = name + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); + + /* function exit code */ + __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":313 + * 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":312 + * def __init__(self, name): + * self.name = name + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name + * +*/ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf___pyx_MemviewEnum___reduce_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + 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 and _dict: +*/ + __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __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 and _dict: + * state += (_dict,) +*/ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_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 and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + __pyx_t_3 = (__pyx_v__dict != Py_None); + if (__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v__dict); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 7, __pyx_L1_error) + __pyx_t_2 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: + * 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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict) != (0)) __PYX_ERR(1, 8, __pyx_L1_error); + __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 and _dict: + * 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 and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.name is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state +*/ + /*else*/ { + __pyx_t_2 = (__pyx_v_self->name != Py_None); + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.name is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state + * else: +*/ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.name is not None + * if use_setstate: + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_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)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_136983863); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_136983863); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_136983863) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __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), 0x82a3537, None), state + * else: +*/ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state + * else: + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Enum__set_state(self, __pyx_state) +*/ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_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)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_136983863); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_136983863); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_136983863) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __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), 0x82a3537, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state(self, __pyx_state) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 16, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(1, 16, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 16, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __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; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Enum__set_state(self, __pyx_state) # <<<<<<<<<<<<<< +*/ + __pyx_t_1 = __pyx_v___pyx_state; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 17, __pyx_L1_error) + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared 'not None'"); + __PYX_ERR(1, 17, __pyx_L1_error) + } + __pyx_t_2 = __pyx_unpickle_Enum__set_state(__pyx_v_self, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state(self, __pyx_state) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __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":356 + * cdef const __Pyx_TypeInfo *typeinfo + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< + * self.obj = obj + * self.flags = flags +*/ + +/* Python wrapper */ +static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_obj = 0; + int __pyx_v_flags; + int __pyx_v_dtype_is_object; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_obj,&__pyx_mstate_global->__pyx_n_u_flags,&__pyx_mstate_global->__pyx_n_u_dtype_is_object,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 356, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 356, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 356, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 356, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__cinit__", 0) < (0)) __PYX_ERR(1, 356, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, i); __PYX_ERR(1, 356, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 356, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 356, __pyx_L3_error) + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 356, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_obj = values[0]; + __pyx_v_flags = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 356, __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, 356, __pyx_L3_error) + } else { + __pyx_v_dtype_is_object = ((int)0); + } + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, __pyx_nargs); __PYX_ERR(1, 356, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __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 */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __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_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "View.MemoryView":357 + * + * 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":358 + * 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: + * PyObject_GetBuffer(obj, &self.view, flags) +*/ + __pyx_v_self->flags = __pyx_v_flags; + + /* "View.MemoryView":359 + * self.obj = obj + * self.flags = flags + * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< + * PyObject_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: +*/ + __pyx_t_2 = (((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))) == ((PyObject *)__pyx_mstate_global->__pyx_memoryview_type)); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_obj != Py_None); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "View.MemoryView":360 + * self.flags = flags + * if type(self) is memoryview or obj is not None: + * PyObject_GetBuffer(obj, &self.view, flags) # <<<<<<<<<<<<<< + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None +*/ + __pyx_t_3 = PyObject_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 360, __pyx_L1_error) + + /* "View.MemoryView":361 + * if type(self) is memoryview or obj is not None: + * PyObject_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) +*/ + __pyx_t_1 = (((PyObject *)__pyx_v_self->view.obj) == NULL); + if (__pyx_t_1) { + + /* "View.MemoryView":362 + * PyObject_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":363 + * 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":361 + * if type(self) is memoryview or obj is not None: + * PyObject_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) +*/ + } + + /* "View.MemoryView":359 + * self.obj = obj + * self.flags = flags + * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< + * PyObject_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: +*/ + } + + /* "View.MemoryView":365 + * Py_INCREF(Py_None) + * + * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< + * global __pyx_memoryview_thread_locks_used + * if (__pyx_memoryview_thread_locks_used < 8 and +*/ + __pyx_t_1 = (!__PYX_CYTHON_ATOMICS_ENABLED()); + if (__pyx_t_1) { + + /* "View.MemoryView":367 + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + * global __pyx_memoryview_thread_locks_used + * if (__pyx_memoryview_thread_locks_used < 8 and # <<<<<<<<<<<<<< + * + * not __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING()): +*/ + __pyx_t_2 = (__pyx_memoryview_thread_locks_used < 8); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L9_bool_binop_done; + } + + /* "View.MemoryView":369 + * if (__pyx_memoryview_thread_locks_used < 8 and + * + * not __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING()): # <<<<<<<<<<<<<< + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 +*/ + __pyx_t_2 = (!__PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING()); + __pyx_t_1 = __pyx_t_2; + __pyx_L9_bool_binop_done:; + + /* "View.MemoryView":367 + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + * global __pyx_memoryview_thread_locks_used + * if (__pyx_memoryview_thread_locks_used < 8 and # <<<<<<<<<<<<<< + * + * not __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING()): +*/ + if (__pyx_t_1) { + + /* "View.MemoryView":370 + * + * not __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING()): + * 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":371 + * not __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING()): + * 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":367 + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + * global __pyx_memoryview_thread_locks_used + * if (__pyx_memoryview_thread_locks_used < 8 and # <<<<<<<<<<<<<< + * + * not __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING()): +*/ + } + + /* "View.MemoryView":372 + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: # <<<<<<<<<<<<<< + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: +*/ + __pyx_t_1 = (__pyx_v_self->lock == NULL); + if (__pyx_t_1) { + + /* "View.MemoryView":373 + * __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":374 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * +*/ + __pyx_t_1 = (__pyx_v_self->lock == NULL); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":375 + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: +*/ + PyErr_NoMemory(); __PYX_ERR(1, 375, __pyx_L1_error) + + /* "View.MemoryView":374 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * +*/ + } + + /* "View.MemoryView":372 + * 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":365 + * Py_INCREF(Py_None) + * + * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< + * global __pyx_memoryview_thread_locks_used + * if (__pyx_memoryview_thread_locks_used < 8 and +*/ + } + + /* "View.MemoryView":377 + * 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":378 + * + * if flags & PyBUF_FORMAT: + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') # <<<<<<<<<<<<<< + * else: + * self.dtype_is_object = dtype_is_object +*/ + __pyx_t_2 = ((__pyx_v_self->view.format[0]) == 'O'); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L14_bool_binop_done; + } + __pyx_t_2 = ((__pyx_v_self->view.format[1]) == '\x00'); + __pyx_t_1 = __pyx_t_2; + __pyx_L14_bool_binop_done:; + __pyx_v_self->dtype_is_object = __pyx_t_1; + + /* "View.MemoryView":377 + * 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_L13; + } + + /* "View.MemoryView":380 + * 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 # <<<<<<<<<<<<<< + * + * with cython.cdivision(True): +*/ + /*else*/ { + __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object; + } + __pyx_L13:; + + /* "View.MemoryView":383 + * + * with cython.cdivision(True): + * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0 # <<<<<<<<<<<<<< + * self.typeinfo = NULL + * +*/ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = ((((Py_intptr_t)(&__pyx_v_self->acquisition_count)) % (sizeof(__pyx_atomic_int_type))) == 0); + if (unlikely(!__pyx_t_1)) { + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_AssertionError))), 0, 0, 0); + __PYX_ERR(1, 383, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(1, 383, __pyx_L1_error) + #endif + + /* "View.MemoryView":384 + * with cython.cdivision(True): + * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0 + * self.typeinfo = NULL # <<<<<<<<<<<<<< + * + * def __dealloc__(memoryview self): +*/ + __pyx_v_self->typeinfo = NULL; + + /* "View.MemoryView":356 + * cdef const __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":386 + * self.typeinfo = NULL + * + * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< + * if self.obj is not None: + * PyBuffer_Release(&self.view) +*/ + +/* Python wrapper */ +static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __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; + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyThread_type_lock __pyx_t_5; + PyThread_type_lock __pyx_t_6; + + /* "View.MemoryView":387 + * + * def __dealloc__(memoryview self): + * if self.obj is not None: # <<<<<<<<<<<<<< + * PyBuffer_Release(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: +*/ + __pyx_t_1 = (__pyx_v_self->obj != Py_None); + if (__pyx_t_1) { + + /* "View.MemoryView":388 + * def __dealloc__(memoryview self): + * if self.obj is not None: + * PyBuffer_Release(&self.view) # <<<<<<<<<<<<<< + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + * +*/ + PyBuffer_Release((&__pyx_v_self->view)); + + /* "View.MemoryView":387 + * + * def __dealloc__(memoryview self): + * if self.obj is not None: # <<<<<<<<<<<<<< + * PyBuffer_Release(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":389 + * if self.obj is not None: + * PyBuffer_Release(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< + * + * (<__pyx_buffer *> &self.view).obj = NULL +*/ + __pyx_t_1 = (((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None); + if (__pyx_t_1) { + + /* "View.MemoryView":391 + * 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":392 + * + * (<__pyx_buffer *> &self.view).obj = NULL + * Py_DECREF(Py_None) # <<<<<<<<<<<<<< + * + * cdef int i +*/ + Py_DECREF(Py_None); + + /* "View.MemoryView":389 + * if self.obj is not None: + * PyBuffer_Release(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< + * + * (<__pyx_buffer *> &self.view).obj = NULL +*/ + } + __pyx_L3:; + + /* "View.MemoryView":396 + * cdef int i + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: # <<<<<<<<<<<<<< + * for i in range(0 if __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() else __pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: +*/ + __pyx_t_1 = (__pyx_v_self->lock != NULL); + if (__pyx_t_1) { + + /* "View.MemoryView":397 + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: + * for i in range(0 if __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() else __pyx_memoryview_thread_locks_used): # <<<<<<<<<<<<<< + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 +*/ + __pyx_t_1 = __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING(); + if (__pyx_t_1) { + __pyx_t_2 = 0; + } else { + __pyx_t_2 = __pyx_memoryview_thread_locks_used; + } + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":398 + * if self.lock != NULL: + * for i in range(0 if __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() else __pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: +*/ + __pyx_t_1 = ((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock); + if (__pyx_t_1) { + + /* "View.MemoryView":399 + * for i in range(0 if __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() else __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":400 + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) +*/ + __pyx_t_1 = (__pyx_v_i != __pyx_memoryview_thread_locks_used); + if (__pyx_t_1) { + + /* "View.MemoryView":402 + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) # <<<<<<<<<<<<<< + * break + * else: +*/ + __pyx_t_5 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); + __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_v_i]); + + /* "View.MemoryView":401 + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + * break +*/ + (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_5; + (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_6; + + /* "View.MemoryView":400 + * 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":403 + * __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":398 + * if self.lock != NULL: + * for i in range(0 if __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() else __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":405 + * 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":396 + * cdef int i + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: # <<<<<<<<<<<<<< + * for i in range(0 if __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() else __pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: +*/ + } + + /* "View.MemoryView":386 + * self.typeinfo = NULL + * + * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< + * if self.obj is not None: + * PyBuffer_Release(&self.view) +*/ + + /* function exit code */ +} + +/* "View.MemoryView":407 + * 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":409 + * 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":411 + * 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, 411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 411, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 411, __pyx_L1_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_2, __pyx_t_3, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_3; + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 411, __pyx_L1_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3)); + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); + #endif + ++__pyx_t_3; + } + if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 411, __pyx_L1_error) + } else { + __pyx_t_5 = __pyx_t_4(__pyx_t_2); + if (unlikely(!__pyx_t_5)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(1, 411, __pyx_L1_error) + PyErr_Clear(); + } + 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":412 + * + * 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, 412, __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 == ((void *)NULL))) __PYX_ERR(1, 412, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_7; + + /* "View.MemoryView":411 + * 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":414 + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * + * return itemp # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = __pyx_v_itemp; + goto __pyx_L0; + + /* "View.MemoryView":407 + * 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":417 + * + * + * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< + * if index is Ellipsis: + * return self +*/ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index); /*proto*/ +static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { + PyObject *__pyx_v_have_slices = NULL; + PyObject *__pyx_v_indices = NULL; + char *__pyx_v_itemp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + char *__pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "View.MemoryView":418 + * + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self + * +*/ + __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis); + if (__pyx_t_1) { + + /* "View.MemoryView":419 + * 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":418 + * + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self + * +*/ + } + + /* "View.MemoryView":421 + * return self + * + * have_slices, indices = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< + * + * cdef char *itemp +*/ + __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 421, __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_PyTuple_GET_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 421, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 421, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 421, __pyx_L1_error) + } + __pyx_v_have_slices = __pyx_t_3; + __pyx_t_3 = 0; + __pyx_v_indices = __pyx_t_4; + __pyx_t_4 = 0; + + /* "View.MemoryView":424 + * + * cdef char *itemp + * if have_slices: # <<<<<<<<<<<<<< + * return memview_slice(self, indices) + * else: +*/ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 424, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":425 + * cdef char *itemp + * if have_slices: + * return memview_slice(self, indices) # <<<<<<<<<<<<<< + * else: + * itemp = self.get_item_pointer(indices) +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":424 + * + * cdef char *itemp + * if have_slices: # <<<<<<<<<<<<<< + * return memview_slice(self, indices) + * else: +*/ + } + + /* "View.MemoryView":427 + * return memview_slice(self, indices) + * else: + * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< + * return self.convert_item_to_object(itemp) + * +*/ + /*else*/ { + __pyx_t_5 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_5 == ((void *)NULL))) __PYX_ERR(1, 427, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_5; + + /* "View.MemoryView":428 + * else: + * itemp = self.get_item_pointer(indices) + * return self.convert_item_to_object(itemp) # <<<<<<<<<<<<<< + * + * def __setitem__(memoryview self, object index, object value): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":417 + * + * + * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< + * if index is Ellipsis: + * return self +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView.memoryview.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_have_slices); + __Pyx_XDECREF(__pyx_v_indices); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":430 + * return self.convert_item_to_object(itemp) + * + * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< + * if self.view.readonly: + * raise TypeError, "Cannot assign to read-only memoryview" +*/ + +/* Python wrapper */ +static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + PyObject *__pyx_v_have_slices = NULL; + PyObject *__pyx_v_obj = NULL; + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + __Pyx_INCREF(__pyx_v_index); + + /* "View.MemoryView":431 + * + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError, "Cannot assign to read-only memoryview" + * +*/ + if (unlikely(__pyx_v_self->view.readonly)) { + + /* "View.MemoryView":432 + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: + * raise TypeError, "Cannot assign to read-only memoryview" # <<<<<<<<<<<<<< + * + * have_slices, index = _unellipsify(index, self.view.ndim) +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_mstate_global->__pyx_kp_u_Cannot_assign_to_read_only_memor, 0, 0); + __PYX_ERR(1, 432, __pyx_L1_error) + + /* "View.MemoryView":431 + * + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError, "Cannot assign to read-only memoryview" + * +*/ + } + + /* "View.MemoryView":434 + * raise TypeError, "Cannot assign to read-only memoryview" + * + * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< + * + * if have_slices: +*/ + __pyx_t_1 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (likely(__pyx_t_1 != Py_None)) { + PyObject* sequence = __pyx_t_1; + Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 434, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 434, __pyx_L1_error) + } + __pyx_v_have_slices = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":436 + * have_slices, index = _unellipsify(index, self.view.ndim) + * + * if have_slices: # <<<<<<<<<<<<<< + * obj = self.is_slice(value) + * if obj is not None: +*/ + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(1, 436, __pyx_L1_error) + if (__pyx_t_4) { + + /* "View.MemoryView":437 + * + * if have_slices: + * obj = self.is_slice(value) # <<<<<<<<<<<<<< + * if obj is not None: + * self.setitem_slice_assignment(self[index], obj) +*/ + __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 437, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_obj = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":438 + * if have_slices: + * obj = self.is_slice(value) + * if obj is not None: # <<<<<<<<<<<<<< + * self.setitem_slice_assignment(self[index], obj) + * else: +*/ + __pyx_t_4 = (__pyx_v_obj != Py_None); + if (__pyx_t_4) { + + /* "View.MemoryView":439 + * obj = self.is_slice(value) + * if obj is not None: + * self.setitem_slice_assignment(self[index], obj) # <<<<<<<<<<<<<< + * else: + * self.setitem_slice_assign_scalar(self[index], value) +*/ + __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 439, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_1, __pyx_v_obj); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 439, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":438 + * if have_slices: + * obj = self.is_slice(value) + * if obj is not None: # <<<<<<<<<<<<<< + * self.setitem_slice_assignment(self[index], obj) + * else: +*/ + goto __pyx_L5; + } + + /* "View.MemoryView":441 + * self.setitem_slice_assignment(self[index], obj) + * else: + * self.setitem_slice_assign_scalar(self[index], value) # <<<<<<<<<<<<<< + * else: + * self.setitem_indexed(index, value) +*/ + /*else*/ { + __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_mstate_global->__pyx_memoryview_type))))) __PYX_ERR(1, 441, __pyx_L1_error) + __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_3), __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L5:; + + /* "View.MemoryView":436 + * have_slices, index = _unellipsify(index, self.view.ndim) + * + * if have_slices: # <<<<<<<<<<<<<< + * obj = self.is_slice(value) + * if obj is not None: +*/ + goto __pyx_L4; + } + + /* "View.MemoryView":443 + * self.setitem_slice_assign_scalar(self[index], value) + * else: + * self.setitem_indexed(index, value) # <<<<<<<<<<<<<< + * + * cdef is_slice(self, obj): +*/ + /*else*/ { + __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 443, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L4:; + + /* "View.MemoryView":430 + * return self.convert_item_to_object(itemp) + * + * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< + * if self.view.readonly: + * raise TypeError, "Cannot assign to read-only memoryview" +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_have_slices); + __Pyx_XDECREF(__pyx_v_obj); + __Pyx_XDECREF(__pyx_v_index); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":445 + * 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; + 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("is_slice", 0); + __Pyx_INCREF(__pyx_v_obj); + + /* "View.MemoryView":446 + * + * 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_mstate_global->__pyx_memoryview_type); + __pyx_t_2 = (!__pyx_t_1); + if (__pyx_t_2) { + + /* "View.MemoryView":447 + * 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":448 + * if not isinstance(obj, memoryview): + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< + * self.dtype_is_object) + * except TypeError: +*/ + __pyx_t_7 = NULL; + __pyx_t_8 = __Pyx_PyLong_From_int(((__pyx_v_self->flags & (~PyBUF_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 448, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_8); + + /* "View.MemoryView":449 + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) # <<<<<<<<<<<<<< + * except TypeError: + * return None +*/ + __pyx_t_9 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 449, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = 1; + { + PyObject *__pyx_callargs[4] = {__pyx_t_7, __pyx_v_obj, __pyx_t_8, __pyx_t_9}; + __pyx_t_6 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_memoryview_type, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 448, __pyx_L4_error) + __Pyx_GOTREF((PyObject *)__pyx_t_6); + } + __Pyx_DECREF_SET(__pyx_v_obj, ((PyObject *)__pyx_t_6)); + __pyx_t_6 = 0; + + /* "View.MemoryView":447 + * 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; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "View.MemoryView":450 + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + * except TypeError: # <<<<<<<<<<<<<< + * return None + * +*/ + __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_TypeError)))); + if (__pyx_t_11) { + __Pyx_ErrRestore(0,0,0); + + /* "View.MemoryView":451 + * self.dtype_is_object) + * except TypeError: + * return None # <<<<<<<<<<<<<< + * + * return obj +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L7_except_return; + } + goto __pyx_L6_except_error; + + /* "View.MemoryView":447 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) +*/ + __pyx_L6_except_error:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + goto __pyx_L1_error; + __pyx_L7_except_return:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + goto __pyx_L0; + __pyx_L9_try_end:; + } + + /* "View.MemoryView":446 + * + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, +*/ + } + + /* "View.MemoryView":453 + * 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":445 + * 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_XDECREF(__pyx_t_9); + __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":455 + * return obj + * + * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice dst_slice + * cdef __Pyx_memviewslice src_slice +*/ + +static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src) { + __Pyx_memviewslice __pyx_v_dst_slice; + __Pyx_memviewslice __pyx_v_src_slice; + __Pyx_memviewslice __pyx_v_msrc; + __Pyx_memviewslice __pyx_v_mdst; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setitem_slice_assignment", 0); + + /* "View.MemoryView":458 + * cdef __Pyx_memviewslice dst_slice + * cdef __Pyx_memviewslice src_slice + * cdef __Pyx_memviewslice msrc = get_slice_from_memview(src, &src_slice)[0] # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] + * +*/ + if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_mstate_global->__pyx_memoryview_type))))) __PYX_ERR(1, 458, __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 == ((void *)NULL))) __PYX_ERR(1, 458, __pyx_L1_error) + __pyx_v_msrc = (__pyx_t_1[0]); + + /* "View.MemoryView":459 + * cdef __Pyx_memviewslice src_slice + * cdef __Pyx_memviewslice msrc = get_slice_from_memview(src, &src_slice)[0] + * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] # <<<<<<<<<<<<<< + * + * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) +*/ + if (!(likely(((__pyx_v_dst) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_dst, __pyx_mstate_global->__pyx_memoryview_type))))) __PYX_ERR(1, 459, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_1 == ((void *)NULL))) __PYX_ERR(1, 459, __pyx_L1_error) + __pyx_v_mdst = (__pyx_t_1[0]); + + /* "View.MemoryView":461 + * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] + * + * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<< + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): +*/ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_mstate_global->__pyx_n_u_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 461, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_As_int(__pyx_t_2); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 461, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_mstate_global->__pyx_n_u_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 461, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyLong_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 461, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __pyx_memoryview_copy_contents(__pyx_v_msrc, __pyx_v_mdst, __pyx_t_3, __pyx_t_4, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 461, __pyx_L1_error) + + /* "View.MemoryView":455 + * return obj + * + * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice dst_slice + * cdef __Pyx_memviewslice src_slice +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assignment", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":463 + * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< + * cdef int array[128] + * cdef void *tmp = NULL +*/ + +static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value) { + int __pyx_v_array[128]; + 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":465 + * 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":470 + * 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 == ((void *)NULL))) __PYX_ERR(1, 470, __pyx_L1_error) + __pyx_v_dst_slice = __pyx_t_1; + + /* "View.MemoryView":472 + * dst_slice = get_slice_from_memview(dst, &tmp_slice) + * + * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: +*/ + __pyx_t_2 = (((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array))); + if (__pyx_t_2) { + + /* "View.MemoryView":473 + * + * 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":474 + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * item = tmp +*/ + __pyx_t_2 = (__pyx_v_tmp == NULL); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":475 + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * item = tmp + * else: +*/ + PyErr_NoMemory(); __PYX_ERR(1, 475, __pyx_L1_error) + + /* "View.MemoryView":474 + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * item = tmp +*/ + } + + /* "View.MemoryView":476 + * if tmp == NULL: + * raise MemoryError + * item = tmp # <<<<<<<<<<<<<< + * else: + * item = array +*/ + __pyx_v_item = __pyx_v_tmp; + + /* "View.MemoryView":472 + * 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":478 + * item = tmp + * else: + * item = array # <<<<<<<<<<<<<< + * + * try: +*/ + /*else*/ { + __pyx_v_item = ((void *)__pyx_v_array); + } + __pyx_L3:; + + /* "View.MemoryView":480 + * item = array + * + * try: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * ( item)[0] = value +*/ + /*try:*/ { + + /* "View.MemoryView":481 + * + * try: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * ( item)[0] = value + * else: +*/ + if (__pyx_v_self->dtype_is_object) { + + /* "View.MemoryView":482 + * 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":481 + * + * try: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * ( item)[0] = value + * else: +*/ + goto __pyx_L8; + } + + /* "View.MemoryView":484 + * ( 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, 484, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L8:; + + /* "View.MemoryView":488 + * + * + * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, +*/ + __pyx_t_2 = (__pyx_v_self->view.suboffsets != NULL); + if (__pyx_t_2) { + + /* "View.MemoryView":489 + * + * if self.view.suboffsets != NULL: + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) # <<<<<<<<<<<<<< + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, + * item, self.dtype_is_object) +*/ + __pyx_t_4 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 489, __pyx_L6_error) + + /* "View.MemoryView":488 + * + * + * 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":490 + * 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":493 + * 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; + __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); + if ( 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); + } + __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":463 + * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< + * cdef int array[128] + * cdef void *tmp = NULL +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":495 + * 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":496 + * + * 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 == ((void *)NULL))) __PYX_ERR(1, 496, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_1; + + /* "View.MemoryView":497 + * 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, 497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":495 + * 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":499 + * 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; + size_t __pyx_t_7; + Py_ssize_t __pyx_t_8; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + 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":502 + * """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_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_struct, 0, 0, NULL, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 502, __pyx_L1_error) + __pyx_t_1 = __pyx_t_2; + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_struct = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":505 + * 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, 505, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_bytesitem = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":506 + * + * 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":507 + * 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_v_struct; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 507, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_6, __pyx_v_bytesitem}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_unpack, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 507, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":506 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: +*/ + } + + /* "View.MemoryView":511 + * raise ValueError, "Unable to convert item to object" + * else: + * if len(self.view.format) == 1: # <<<<<<<<<<<<<< + * return result[0] + * return result +*/ + /*else:*/ { + __pyx_t_8 = __Pyx_ssize_strlen(__pyx_v_self->view.format); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(1, 511, __pyx_L5_except_error) + __pyx_t_9 = (__pyx_t_8 == 1); + if (__pyx_t_9) { + + /* "View.MemoryView":512 + * 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_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 512, __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":511 + * raise ValueError, "Unable to convert item to object" + * else: + * if len(self.view.format) == 1: # <<<<<<<<<<<<<< + * return result[0] + * return result +*/ + } + + /* "View.MemoryView":513 + * 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; + + /* "View.MemoryView":508 + * 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_6, &__pyx_t_5); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_mstate_global->__pyx_n_u_error); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 508, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_10); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_ErrRestore(__pyx_t_1, __pyx_t_6, __pyx_t_5); + __pyx_t_1 = 0; __pyx_t_6 = 0; __pyx_t_5 = 0; + if (__pyx_t_11) { + __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_1) < 0) __PYX_ERR(1, 508, __pyx_L5_except_error) + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_1); + + /* "View.MemoryView":509 + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + * raise ValueError, "Unable to convert item to object" # <<<<<<<<<<<<<< + * else: + * if len(self.view.format) == 1: +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_ValueError))), __pyx_mstate_global->__pyx_kp_u_Unable_to_convert_item_to_object, 0, 0); + __PYX_ERR(1, 509, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + + /* "View.MemoryView":506 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: +*/ + __pyx_L5_except_error:; + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L1_error; + __pyx_L6_except_return:; + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L0; + } + + /* "View.MemoryView":499 + * 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_10); + __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":515 + * 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; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + Py_ssize_t __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + char *__pyx_t_10; + char *__pyx_t_11; + Py_ssize_t __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":518 + * """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_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_struct, 0, 0, NULL, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 518, __pyx_L1_error) + __pyx_t_1 = __pyx_t_2; + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_struct = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":523 + * cdef Py_ssize_t i + * + * if isinstance(value, tuple): # <<<<<<<<<<<<<< + * bytesvalue = struct.pack(self.view.format, *value) + * else: +*/ + __pyx_t_3 = PyTuple_Check(__pyx_v_value); + if (__pyx_t_3) { + + /* "View.MemoryView":524 + * + * 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_mstate_global->__pyx_n_u_pack); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 524, __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, 524, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 524, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4) != (0)) __PYX_ERR(1, 524, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 524, __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, 524, __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, 524, __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) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_4))) __PYX_ERR(1, 524, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":523 + * cdef Py_ssize_t i + * + * if isinstance(value, tuple): # <<<<<<<<<<<<<< + * bytesvalue = struct.pack(self.view.format, *value) + * else: +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":526 + * 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_v_struct; + __Pyx_INCREF(__pyx_t_6); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_1, __pyx_v_value}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_pack, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_4))) __PYX_ERR(1, 526, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + } + __pyx_L3:; + + /* "View.MemoryView":528 + * bytesvalue = struct.pack(self.view.format, value) + * + * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< + * itemp[i] = c + * +*/ + __pyx_t_8 = 0; + if (unlikely(__pyx_v_bytesvalue == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable"); + __PYX_ERR(1, 528, __pyx_L1_error) + } + __Pyx_INCREF(__pyx_v_bytesvalue); + __pyx_t_9 = __pyx_v_bytesvalue; + __pyx_t_11 = __Pyx_PyBytes_AsWritableString(__pyx_t_9); if (unlikely(__pyx_t_11 == ((char *)NULL))) __PYX_ERR(1, 528, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyBytes_GET_SIZE(__pyx_t_9); if (unlikely(__pyx_t_12 == ((Py_ssize_t)-1))) __PYX_ERR(1, 528, __pyx_L1_error) + __pyx_t_13 = (__pyx_t_11 + __pyx_t_12); + for (__pyx_t_14 = __pyx_t_11; __pyx_t_14 < __pyx_t_13; __pyx_t_14++) { + __pyx_t_10 = __pyx_t_14; + __pyx_v_c = (__pyx_t_10[0]); + + /* "View.MemoryView":529 + * + * for i, c in enumerate(bytesvalue): + * itemp[i] = c # <<<<<<<<<<<<<< + * + * @cname('getbuffer') +*/ + __pyx_v_i = __pyx_t_8; + + /* "View.MemoryView":528 + * bytesvalue = struct.pack(self.view.format, value) + * + * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< + * itemp[i] = c + * +*/ + __pyx_t_8 = (__pyx_t_8 + 1); + + /* "View.MemoryView":529 + * + * for i, c in enumerate(bytesvalue): + * itemp[i] = c # <<<<<<<<<<<<<< + * + * @cname('getbuffer') +*/ + (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c; + } + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "View.MemoryView":515 + * 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_9); + __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":531 + * itemp[i] = c + * + * @cname('getbuffer') # <<<<<<<<<<<<<< + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: +*/ + +/* Python wrapper */ +CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + Py_ssize_t *__pyx_t_3; + char *__pyx_t_4; + void *__pyx_t_5; + int __pyx_t_6; + Py_ssize_t __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + if (unlikely(__pyx_v_info == NULL)) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + + /* "View.MemoryView":533 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< + * raise ValueError, "Cannot create writable memory view from read-only memoryview" + * +*/ + __pyx_t_2 = ((__pyx_v_flags & PyBUF_WRITABLE) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_1 = __pyx_v_self->view.readonly; + __pyx_L4_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":534 + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError, "Cannot create writable memory view from read-only memoryview" # <<<<<<<<<<<<<< + * + * if flags & PyBUF_ND: +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_ValueError))), __pyx_mstate_global->__pyx_kp_u_Cannot_create_writable_memory_vi, 0, 0); + __PYX_ERR(1, 534, __pyx_L1_error) + + /* "View.MemoryView":533 + * @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":536 + * 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":537 + * + * if flags & PyBUF_ND: + * info.shape = self.view.shape # <<<<<<<<<<<<<< + * else: + * info.shape = NULL +*/ + __pyx_t_3 = __pyx_v_self->view.shape; + __pyx_v_info->shape = __pyx_t_3; + + /* "View.MemoryView":536 + * 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":539 + * info.shape = self.view.shape + * else: + * info.shape = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_STRIDES: +*/ + /*else*/ { + __pyx_v_info->shape = NULL; + } + __pyx_L6:; + + /* "View.MemoryView":541 + * 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":542 + * + * if flags & PyBUF_STRIDES: + * info.strides = self.view.strides # <<<<<<<<<<<<<< + * else: + * info.strides = NULL +*/ + __pyx_t_3 = __pyx_v_self->view.strides; + __pyx_v_info->strides = __pyx_t_3; + + /* "View.MemoryView":541 + * info.shape = NULL + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.strides = self.view.strides + * else: +*/ + goto __pyx_L7; + } + + /* "View.MemoryView":544 + * info.strides = self.view.strides + * else: + * info.strides = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_INDIRECT: +*/ + /*else*/ { + __pyx_v_info->strides = NULL; + } + __pyx_L7:; + + /* "View.MemoryView":546 + * 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":547 + * + * if flags & PyBUF_INDIRECT: + * info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<< + * else: + * info.suboffsets = NULL +*/ + __pyx_t_3 = __pyx_v_self->view.suboffsets; + __pyx_v_info->suboffsets = __pyx_t_3; + + /* "View.MemoryView":546 + * info.strides = NULL + * + * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< + * info.suboffsets = self.view.suboffsets + * else: +*/ + goto __pyx_L8; + } + + /* "View.MemoryView":549 + * info.suboffsets = self.view.suboffsets + * else: + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: +*/ + /*else*/ { + __pyx_v_info->suboffsets = NULL; + } + __pyx_L8:; + + /* "View.MemoryView":551 + * 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":552 + * + * if flags & PyBUF_FORMAT: + * info.format = self.view.format # <<<<<<<<<<<<<< + * else: + * info.format = NULL +*/ + __pyx_t_4 = __pyx_v_self->view.format; + __pyx_v_info->format = __pyx_t_4; + + /* "View.MemoryView":551 + * info.suboffsets = NULL + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.view.format + * else: +*/ + goto __pyx_L9; + } + + /* "View.MemoryView":554 + * info.format = self.view.format + * else: + * info.format = NULL # <<<<<<<<<<<<<< + * + * info.buf = self.view.buf +*/ + /*else*/ { + __pyx_v_info->format = NULL; + } + __pyx_L9:; + + /* "View.MemoryView":556 + * info.format = NULL + * + * info.buf = self.view.buf # <<<<<<<<<<<<<< + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize +*/ + __pyx_t_5 = __pyx_v_self->view.buf; + __pyx_v_info->buf = __pyx_t_5; + + /* "View.MemoryView":557 + * + * info.buf = self.view.buf + * info.ndim = self.view.ndim # <<<<<<<<<<<<<< + * info.itemsize = self.view.itemsize + * info.len = self.view.len +*/ + __pyx_t_6 = __pyx_v_self->view.ndim; + __pyx_v_info->ndim = __pyx_t_6; + + /* "View.MemoryView":558 + * info.buf = self.view.buf + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize # <<<<<<<<<<<<<< + * info.len = self.view.len + * info.readonly = self.view.readonly +*/ + __pyx_t_7 = __pyx_v_self->view.itemsize; + __pyx_v_info->itemsize = __pyx_t_7; + + /* "View.MemoryView":559 + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize + * info.len = self.view.len # <<<<<<<<<<<<<< + * info.readonly = self.view.readonly + * info.obj = self +*/ + __pyx_t_7 = __pyx_v_self->view.len; + __pyx_v_info->len = __pyx_t_7; + + /* "View.MemoryView":560 + * 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":561 + * info.len = self.view.len + * info.readonly = self.view.readonly + * info.obj = self # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_INCREF((PyObject *)__pyx_v_self); + __Pyx_GIVEREF((PyObject *)__pyx_v_self); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + + /* "View.MemoryView":531 + * itemp[i] = c + * + * @cname('getbuffer') # <<<<<<<<<<<<<< + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.memoryview.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":564 + * + * + * @property # <<<<<<<<<<<<<< + * def T(self): + * cdef _memoryviewslice result = memoryview_copy(self) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __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":566 + * @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, 566, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_memoryviewslice_type))))) __PYX_ERR(1, 566, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":567 + * def T(self): + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) # <<<<<<<<<<<<<< + * return result + * +*/ + __pyx_t_2 = __pyx_memslice_transpose((&__pyx_v_result->from_slice)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 567, __pyx_L1_error) + + /* "View.MemoryView":568 + * 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":564 + * + * + * @property # <<<<<<<<<<<<<< + * def T(self): + * cdef _memoryviewslice result = memoryview_copy(self) +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.T.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":570 + * return result + * + * @property # <<<<<<<<<<<<<< + * def base(self): + * return self._get_base() +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":572 + * @property + * def base(self): + * return self._get_base() # <<<<<<<<<<<<<< + * + * cdef _get_base(self): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->_get_base(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":570 + * return result + * + * @property # <<<<<<<<<<<<<< + * def base(self): + * return self._get_base() +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.base.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":574 + * return self._get_base() + * + * cdef _get_base(self): # <<<<<<<<<<<<<< + * return self.obj + * +*/ + +static PyObject *__pyx_memoryview__get_base(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_get_base", 0); + + /* "View.MemoryView":575 + * + * cdef _get_base(self): + * return self.obj # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->obj); + __pyx_r = __pyx_v_self->obj; + goto __pyx_L0; + + /* "View.MemoryView":574 + * return self._get_base() + * + * cdef _get_base(self): # <<<<<<<<<<<<<< + * return self.obj + * +*/ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":577 + * return self.obj + * + * @property # <<<<<<<<<<<<<< + * def shape(self): + * return tuple([length for length in self.view.shape[:self.view.ndim]]) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_7genexpr__pyx_v_length; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":579 + * @property + * def shape(self): + * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); + for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { + __pyx_t_2 = __pyx_t_4; + __pyx_7genexpr__pyx_v_length = (__pyx_t_2[0]); + __pyx_t_5 = PyLong_FromSsize_t(__pyx_7genexpr__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 579, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } /* exit inner scope */ + __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 579, __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":577 + * return self.obj + * + * @property # <<<<<<<<<<<<<< + * def shape(self): + * return tuple([length for length in self.view.shape[:self.view.ndim]]) +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.shape.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":581 + * return tuple([length for length in self.view.shape[:self.view.ndim]]) + * + * @property # <<<<<<<<<<<<<< + * def strides(self): + * if self.view.strides == NULL: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_8genexpr1__pyx_v_stride; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":583 + * @property + * def strides(self): + * if self.view.strides == NULL: # <<<<<<<<<<<<<< + * + * raise ValueError, "Buffer view does not expose strides" +*/ + __pyx_t_1 = (__pyx_v_self->view.strides == NULL); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":585 + * if self.view.strides == NULL: + * + * raise ValueError, "Buffer view does not expose strides" # <<<<<<<<<<<<<< + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_ValueError))), __pyx_mstate_global->__pyx_kp_u_Buffer_view_does_not_expose_stri, 0, 0); + __PYX_ERR(1, 585, __pyx_L1_error) + + /* "View.MemoryView":583 + * @property + * def strides(self): + * if self.view.strides == NULL: # <<<<<<<<<<<<<< + * + * raise ValueError, "Buffer view does not expose strides" +*/ + } + + /* "View.MemoryView":587 + * raise ValueError, "Buffer view does not expose strides" + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 587, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = (__pyx_v_self->view.strides + __pyx_v_self->view.ndim); + for (__pyx_t_5 = __pyx_v_self->view.strides; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { + __pyx_t_3 = __pyx_t_5; + __pyx_8genexpr1__pyx_v_stride = (__pyx_t_3[0]); + __pyx_t_6 = PyLong_FromSsize_t(__pyx_8genexpr1__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 587, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 587, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } /* exit inner scope */ + __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 587, __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":581 + * return tuple([length for length in self.view.shape[:self.view.ndim]]) + * + * @property # <<<<<<<<<<<<<< + * def strides(self): + * if self.view.strides == NULL: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView.memoryview.strides.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":589 + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) + * + * @property # <<<<<<<<<<<<<< + * def suboffsets(self): + * if self.view.suboffsets == NULL: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_8genexpr2__pyx_v_suboffset; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":591 + * @property + * def suboffsets(self): + * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< + * return (-1,) * self.view.ndim + * +*/ + __pyx_t_1 = (__pyx_v_self->view.suboffsets == NULL); + if (__pyx_t_1) { + + /* "View.MemoryView":592 + * def suboffsets(self): + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PySequence_Multiply(__pyx_mstate_global->__pyx_tuple[0], __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":591 + * @property + * def suboffsets(self): + * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< + * return (-1,) * self.view.ndim + * +*/ + } + + /* "View.MemoryView":594 + * return (-1,) * self.view.ndim + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 594, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim); + for (__pyx_t_5 = __pyx_v_self->view.suboffsets; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { + __pyx_t_3 = __pyx_t_5; + __pyx_8genexpr2__pyx_v_suboffset = (__pyx_t_3[0]); + __pyx_t_6 = PyLong_FromSsize_t(__pyx_8genexpr2__pyx_v_suboffset); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 594, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 594, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } /* exit inner scope */ + __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 594, __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":589 + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) + * + * @property # <<<<<<<<<<<<<< + * def suboffsets(self): + * if self.view.suboffsets == NULL: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView.memoryview.suboffsets.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":596 + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) + * + * @property # <<<<<<<<<<<<<< + * def ndim(self): + * return self.view.ndim +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __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":598 + * @property + * def ndim(self): + * return self.view.ndim # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":596 + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) + * + * @property # <<<<<<<<<<<<<< + * def ndim(self): + * return self.view.ndim +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.ndim.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":600 + * return self.view.ndim + * + * @property # <<<<<<<<<<<<<< + * def itemsize(self): + * return self.view.itemsize +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __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":602 + * @property + * def itemsize(self): + * return self.view.itemsize # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyLong_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 602, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":600 + * return self.view.ndim + * + * @property # <<<<<<<<<<<<<< + * def itemsize(self): + * return self.view.itemsize +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.itemsize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":604 + * return self.view.itemsize + * + * @property # <<<<<<<<<<<<<< + * def nbytes(self): + * return self.size * self.view.itemsize +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __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":606 + * @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_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 606, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyLong_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 606, __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, 606, __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":604 + * return self.view.itemsize + * + * @property # <<<<<<<<<<<<<< + * def nbytes(self): + * return self.size * self.view.itemsize +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.nbytes.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":608 + * return self.size * self.view.itemsize + * + * @property # <<<<<<<<<<<<<< + * def size(self): + * if self._size is None: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_v_length = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":610 + * @property + * def size(self): + * if self._size is None: # <<<<<<<<<<<<<< + * result = 1 + * +*/ + __pyx_t_1 = (__pyx_v_self->_size == Py_None); + if (__pyx_t_1) { + + /* "View.MemoryView":611 + * def size(self): + * if self._size is None: + * result = 1 # <<<<<<<<<<<<<< + * + * for length in self.view.shape[:self.view.ndim]: +*/ + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __pyx_v_result = __pyx_mstate_global->__pyx_int_1; + + /* "View.MemoryView":613 + * result = 1 + * + * for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<< + * result *= length + * +*/ + __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); + for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { + __pyx_t_2 = __pyx_t_4; + __pyx_t_5 = PyLong_FromSsize_t((__pyx_t_2[0])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 613, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_5); + __pyx_t_5 = 0; + + /* "View.MemoryView":614 + * + * for length in self.view.shape[:self.view.ndim]: + * result *= length # <<<<<<<<<<<<<< + * + * self._size = result +*/ + __pyx_t_5 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_5); + __pyx_t_5 = 0; + } + + /* "View.MemoryView":616 + * 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":610 + * @property + * def size(self): + * if self._size is None: # <<<<<<<<<<<<<< + * result = 1 + * +*/ + } + + /* "View.MemoryView":618 + * 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":608 + * return self.size * self.view.itemsize + * + * @property # <<<<<<<<<<<<<< + * def size(self): + * if self._size is None: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_length); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":620 + * return self._size + * + * def __len__(self): # <<<<<<<<<<<<<< + * if self.view.ndim >= 1: + * return self.view.shape[0] +*/ + +/* Python wrapper */ +static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self); /*proto*/ +static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __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; + int __pyx_t_1; + + /* "View.MemoryView":621 + * + * def __len__(self): + * if self.view.ndim >= 1: # <<<<<<<<<<<<<< + * return self.view.shape[0] + * +*/ + __pyx_t_1 = (__pyx_v_self->view.ndim >= 1); + if (__pyx_t_1) { + + /* "View.MemoryView":622 + * 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":621 + * + * def __len__(self): + * if self.view.ndim >= 1: # <<<<<<<<<<<<<< + * return self.view.shape[0] + * +*/ + } + + /* "View.MemoryView":624 + * return self.view.shape[0] + * + * return 0 # <<<<<<<<<<<<<< + * + * def __repr__(self): +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":620 + * return self._size + * + * def __len__(self): # <<<<<<<<<<<<<< + * if self.view.ndim >= 1: + * return self.view.shape[0] +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":626 + * return 0 + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__, + * id(self)) +*/ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __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; + PyObject *__pyx_t_4[5]; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "View.MemoryView":627 + * + * 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_mstate_global->__pyx_n_u_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 627, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 627, __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_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 627, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_1), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 627, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":628 + * def __repr__(self): + * return "" % (self.base.__class__.__name__, + * id(self)) # <<<<<<<<<<<<<< + * + * def __str__(self): +*/ + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 628, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_x); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 628, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_4[0] = __pyx_mstate_global->__pyx_kp_u_MemoryView_of; + __pyx_t_4[1] = __pyx_t_2; + __pyx_t_4[2] = __pyx_mstate_global->__pyx_kp_u_at_0x; + __pyx_t_4[3] = __pyx_t_3; + __pyx_t_4[4] = __pyx_mstate_global->__pyx_kp_u__3; + + /* "View.MemoryView":627 + * + * def __repr__(self): + * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< + * id(self)) + * +*/ + __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_4, 5, 15 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 6 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3)); + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 627, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":626 + * 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":630 + * id(self)) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__,) + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __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; + PyObject *__pyx_t_3[3]; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__str__", 0); + + /* "View.MemoryView":631 + * + * def __str__(self): + * return "" % (self.base.__class__.__name__,) # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 631, __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_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_1), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3[0] = __pyx_mstate_global->__pyx_kp_u_MemoryView_of; + __pyx_t_3[1] = __pyx_t_2; + __pyx_t_3[2] = __pyx_mstate_global->__pyx_kp_u_object; + __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, 15 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 8, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2)); + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 631, __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":630 + * 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":634 + * + * + * def is_c_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp +*/ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_c_contig (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("is_c_contig", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("is_c_contig", __pyx_kwds); return NULL;} + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice *__pyx_v_mslice; + __Pyx_memviewslice __pyx_v_tmp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_c_contig", 0); + + /* "View.MemoryView":637 + * 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 == ((void *)NULL))) __PYX_ERR(1, 637, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":638 + * 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, 638, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":634 + * + * + * 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":640 + * return slice_is_contig(mslice[0], 'C', self.view.ndim) + * + * def is_f_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp +*/ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_f_contig (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("is_f_contig", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("is_f_contig", __pyx_kwds); return NULL;} + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice *__pyx_v_mslice; + __Pyx_memviewslice __pyx_v_tmp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_f_contig", 0); + + /* "View.MemoryView":643 + * 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 == ((void *)NULL))) __PYX_ERR(1, 643, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":644 + * 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, 644, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":640 + * 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":646 + * return slice_is_contig(mslice[0], 'F', self.view.ndim) + * + * def copy(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice mslice + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS +*/ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("copy", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("copy", __pyx_kwds); return NULL;} + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice __pyx_v_mslice; + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("copy", 0); + + /* "View.MemoryView":648 + * 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":650 + * 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":651 + * + * 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), __pyx_k_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, 651, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":656 + * 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, 656, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":646 + * 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":658 + * return memoryview_copy_from_slice(self, &mslice) + * + * def copy_fortran(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice src, dst + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS +*/ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy_fortran (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("copy_fortran", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("copy_fortran", __pyx_kwds); return NULL;} + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice __pyx_v_src; + __Pyx_memviewslice __pyx_v_dst; + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("copy_fortran", 0); + + /* "View.MemoryView":660 + * 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":662 + * 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":663 + * + * 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), __pyx_k_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, 663, __pyx_L1_error) + __pyx_v_dst = __pyx_t_1; + + /* "View.MemoryView":668 + * 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, 668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":658 + * return memoryview_copy_from_slice(self, &mslice) + * + * def copy_fortran(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice src, dst + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.copy_fortran", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf___pyx_memoryview___reduce_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.memoryview.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 3, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(1, 3, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 3, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf___pyx_memoryview_2__setstate_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":671 + * + * + * @cname('__pyx_memoryview_new') # <<<<<<<<<<<<<< + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, const __Pyx_TypeInfo *typeinfo): + * cdef memoryview result = memoryview(o, flags, dtype_is_object) +*/ + +static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, int __pyx_v_dtype_is_object, __Pyx_TypeInfo const *__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; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_cwrapper", 0); + + /* "View.MemoryView":673 + * @cname('__pyx_memoryview_new') + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, const __Pyx_TypeInfo *typeinfo): + * cdef memoryview result = memoryview(o, flags, dtype_is_object) # <<<<<<<<<<<<<< + * result.typeinfo = typeinfo + * return result +*/ + __pyx_t_2 = NULL; + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 673, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 673, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[4] = {__pyx_t_2, __pyx_v_o, __pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_memoryview_type, __pyx_callargs+__pyx_t_5, (4-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 673, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + } + __pyx_v_result = ((struct __pyx_memoryview_obj *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":674 + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, const __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":675 + * 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":671 + * + * + * @cname('__pyx_memoryview_new') # <<<<<<<<<<<<<< + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, const __Pyx_TypeInfo *typeinfo): + * cdef memoryview result = memoryview(o, flags, 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_XDECREF(__pyx_t_4); + __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":677 + * return result + * + * @cname('__pyx_memoryview_check') # <<<<<<<<<<<<<< + * cdef inline bint memoryview_check(object o) noexcept: + * return isinstance(o, memoryview) +*/ + +static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { + int __pyx_r; + int __pyx_t_1; + + /* "View.MemoryView":679 + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o) noexcept: + * return isinstance(o, memoryview) # <<<<<<<<<<<<<< + * + * cdef tuple _unellipsify(object index, int ndim): +*/ + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_o, __pyx_mstate_global->__pyx_memoryview_type); + __pyx_r = __pyx_t_1; + goto __pyx_L0; + + /* "View.MemoryView":677 + * return result + * + * @cname('__pyx_memoryview_check') # <<<<<<<<<<<<<< + * cdef inline bint memoryview_check(object o) noexcept: + * return isinstance(o, memoryview) +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":681 + * return isinstance(o, memoryview) + * + * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< + * """ + * Replace all ellipses with full slices and fill incomplete indices with +*/ + +static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { + Py_ssize_t __pyx_v_idx; + PyObject *__pyx_v_tup = NULL; + PyObject *__pyx_v_result = NULL; + int __pyx_v_have_slices; + int __pyx_v_seen_ellipsis; + PyObject *__pyx_v_item = NULL; + Py_ssize_t __pyx_v_nslices; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + PyObject *__pyx_t_6[3]; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_unellipsify", 0); + + /* "View.MemoryView":687 + * """ + * cdef Py_ssize_t idx + * tup = index if isinstance(index, tuple) else (index,) # <<<<<<<<<<<<<< + * + * result = [slice(None)] * ndim +*/ + __pyx_t_2 = PyTuple_Check(__pyx_v_index); + if (__pyx_t_2) { + __Pyx_INCREF(((PyObject*)__pyx_v_index)); + __pyx_t_1 = __pyx_v_index; + } else { + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 687, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_index); + __Pyx_GIVEREF(__pyx_v_index); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_index) != (0)) __PYX_ERR(1, 687, __pyx_L1_error); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + } + __pyx_v_tup = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":689 + * tup = index if isinstance(index, tuple) else (index,) + * + * result = [slice(None)] * ndim # <<<<<<<<<<<<<< + * have_slices = False + * seen_ellipsis = False +*/ + __pyx_t_1 = PyList_New(1 * ((__pyx_v_ndim<0) ? 0:__pyx_v_ndim)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 689, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < __pyx_v_ndim; __pyx_temp++) { + __Pyx_INCREF(__pyx_mstate_global->__pyx_slice[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[0]); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, __pyx_temp, __pyx_mstate_global->__pyx_slice[0]) != (0)) __PYX_ERR(1, 689, __pyx_L1_error); + } + } + __pyx_v_result = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":690 + * + * result = [slice(None)] * ndim + * have_slices = False # <<<<<<<<<<<<<< + * seen_ellipsis = False + * idx = 0 +*/ + __pyx_v_have_slices = 0; + + /* "View.MemoryView":691 + * result = [slice(None)] * ndim + * have_slices = False + * seen_ellipsis = False # <<<<<<<<<<<<<< + * idx = 0 + * for item in tup: +*/ + __pyx_v_seen_ellipsis = 0; + + /* "View.MemoryView":692 + * have_slices = False + * seen_ellipsis = False + * idx = 0 # <<<<<<<<<<<<<< + * for item in tup: + * if item is Ellipsis: +*/ + __pyx_v_idx = 0; + + /* "View.MemoryView":693 + * seen_ellipsis = False + * idx = 0 + * for item in tup: # <<<<<<<<<<<<<< + * if item is Ellipsis: + * if not seen_ellipsis: +*/ + if (unlikely(__pyx_v_tup == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 693, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 693, __pyx_L1_error) + #endif + if (__pyx_t_4 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4)); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_4); + #endif + ++__pyx_t_4; + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 693, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":694 + * idx = 0 + * for item in tup: + * if item is Ellipsis: # <<<<<<<<<<<<<< + * if not seen_ellipsis: + * idx += ndim - len(tup) +*/ + __pyx_t_2 = (__pyx_v_item == __pyx_builtin_Ellipsis); + if (__pyx_t_2) { + + /* "View.MemoryView":695 + * for item in tup: + * if item is Ellipsis: + * if not seen_ellipsis: # <<<<<<<<<<<<<< + * idx += ndim - len(tup) + * seen_ellipsis = True +*/ + __pyx_t_2 = (!__pyx_v_seen_ellipsis); + if (__pyx_t_2) { + + /* "View.MemoryView":696 + * if item is Ellipsis: + * if not seen_ellipsis: + * idx += ndim - len(tup) # <<<<<<<<<<<<<< + * seen_ellipsis = True + * have_slices = True +*/ + if (unlikely(__pyx_v_tup == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 696, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_PyTuple_GET_SIZE(__pyx_v_tup); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 696, __pyx_L1_error) + __pyx_v_idx = (__pyx_v_idx + (__pyx_v_ndim - __pyx_t_5)); + + /* "View.MemoryView":697 + * if not seen_ellipsis: + * idx += ndim - len(tup) + * seen_ellipsis = True # <<<<<<<<<<<<<< + * have_slices = True + * else: +*/ + __pyx_v_seen_ellipsis = 1; + + /* "View.MemoryView":695 + * for item in tup: + * if item is Ellipsis: + * if not seen_ellipsis: # <<<<<<<<<<<<<< + * idx += ndim - len(tup) + * seen_ellipsis = True +*/ + } + + /* "View.MemoryView":698 + * idx += ndim - len(tup) + * seen_ellipsis = True + * have_slices = True # <<<<<<<<<<<<<< + * else: + * if isinstance(item, slice): +*/ + __pyx_v_have_slices = 1; + + /* "View.MemoryView":694 + * idx = 0 + * for item in tup: + * if item is Ellipsis: # <<<<<<<<<<<<<< + * if not seen_ellipsis: + * idx += ndim - len(tup) +*/ + goto __pyx_L5; + } + + /* "View.MemoryView":700 + * have_slices = True + * else: + * if isinstance(item, slice): # <<<<<<<<<<<<<< + * have_slices = True + * elif not PyIndex_Check(item): +*/ + /*else*/ { + __pyx_t_2 = PySlice_Check(__pyx_v_item); + if (__pyx_t_2) { + + /* "View.MemoryView":701 + * else: + * if isinstance(item, slice): + * have_slices = True # <<<<<<<<<<<<<< + * elif not PyIndex_Check(item): + * raise TypeError, f"Cannot index with type '{type(item)}'" +*/ + __pyx_v_have_slices = 1; + + /* "View.MemoryView":700 + * have_slices = True + * else: + * if isinstance(item, slice): # <<<<<<<<<<<<<< + * have_slices = True + * elif not PyIndex_Check(item): +*/ + goto __pyx_L7; + } + + /* "View.MemoryView":702 + * if isinstance(item, slice): + * have_slices = True + * elif not PyIndex_Check(item): # <<<<<<<<<<<<<< + * raise TypeError, f"Cannot index with type '{type(item)}'" + * result[idx] = item +*/ + __pyx_t_2 = (!(PyIndex_Check(__pyx_v_item) != 0)); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":703 + * have_slices = True + * elif not PyIndex_Check(item): + * raise TypeError, f"Cannot index with type '{type(item)}'" # <<<<<<<<<<<<<< + * result[idx] = item + * idx += 1 +*/ + __pyx_t_3 = __Pyx_PyObject_FormatSimple(((PyObject *)Py_TYPE(__pyx_v_item)), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 703, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6[0] = __pyx_mstate_global->__pyx_kp_u_Cannot_index_with_type; + __pyx_t_6[1] = __pyx_t_3; + __pyx_t_6[2] = __pyx_mstate_global->__pyx_kp_u__4; + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, 24 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3)); + if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 703, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_t_7, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(1, 703, __pyx_L1_error) + + /* "View.MemoryView":702 + * if isinstance(item, slice): + * have_slices = True + * elif not PyIndex_Check(item): # <<<<<<<<<<<<<< + * raise TypeError, f"Cannot index with type '{type(item)}'" + * result[idx] = item +*/ + } + __pyx_L7:; + + /* "View.MemoryView":704 + * elif not PyIndex_Check(item): + * raise TypeError, f"Cannot index with type '{type(item)}'" + * result[idx] = item # <<<<<<<<<<<<<< + * idx += 1 + * +*/ + if (unlikely((__Pyx_SetItemInt(__pyx_v_result, __pyx_v_idx, __pyx_v_item, Py_ssize_t, 1, PyLong_FromSsize_t, 1, 1, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference) < 0))) __PYX_ERR(1, 704, __pyx_L1_error) + } + __pyx_L5:; + + /* "View.MemoryView":705 + * raise TypeError, f"Cannot index with type '{type(item)}'" + * result[idx] = item + * idx += 1 # <<<<<<<<<<<<<< + * + * nslices = ndim - idx +*/ + __pyx_v_idx = (__pyx_v_idx + 1); + + /* "View.MemoryView":693 + * seen_ellipsis = False + * idx = 0 + * for item in tup: # <<<<<<<<<<<<<< + * if item is Ellipsis: + * if not seen_ellipsis: +*/ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":707 + * idx += 1 + * + * nslices = ndim - idx # <<<<<<<<<<<<<< + * return have_slices or nslices, tuple(result) + * +*/ + __pyx_v_nslices = (__pyx_v_ndim - __pyx_v_idx); + + /* "View.MemoryView":708 + * + * nslices = ndim - idx + * return have_slices or nslices, tuple(result) # <<<<<<<<<<<<<< + * + * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: +*/ + __Pyx_XDECREF(__pyx_r); + if (!__pyx_v_have_slices) { + } else { + __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_1 = __pyx_t_7; + __pyx_t_7 = 0; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_7 = PyLong_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_1 = __pyx_t_7; + __pyx_t_7 = 0; + __pyx_L9_bool_binop_done:; + __pyx_t_7 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(1, 708, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7) != (0)) __PYX_ERR(1, 708, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_7 = 0; + __pyx_r = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":681 + * return isinstance(o, memoryview) + * + * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< + * """ + * Replace all ellipses with full slices and fill incomplete indices with +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("View.MemoryView._unellipsify", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_tup); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_item); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":710 + * return have_slices or nslices, tuple(result) + * + * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: # <<<<<<<<<<<<<< + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: +*/ + +static int assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __pyx_v_ndim) { + Py_ssize_t __pyx_v_suboffset; + int __pyx_r; + Py_ssize_t *__pyx_t_1; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":711 + * + * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: + * for suboffset in suboffsets[:ndim]: # <<<<<<<<<<<<<< + * if suboffset >= 0: + * raise ValueError, "Indirect dimensions not supported" +*/ + __pyx_t_2 = (__pyx_v_suboffsets + __pyx_v_ndim); + for (__pyx_t_3 = __pyx_v_suboffsets; __pyx_t_3 < __pyx_t_2; __pyx_t_3++) { + __pyx_t_1 = __pyx_t_3; + __pyx_v_suboffset = (__pyx_t_1[0]); + + /* "View.MemoryView":712 + * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * raise ValueError, "Indirect dimensions not supported" + * return 0 # return type just used as an error flag +*/ + __pyx_t_4 = (__pyx_v_suboffset >= 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":713 + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + * raise ValueError, "Indirect dimensions not supported" # <<<<<<<<<<<<<< + * return 0 # return type just used as an error flag + * +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_ValueError))), __pyx_mstate_global->__pyx_kp_u_Indirect_dimensions_not_supporte, 0, 0); + __PYX_ERR(1, 713, __pyx_L1_error) + + /* "View.MemoryView":712 + * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * raise ValueError, "Indirect dimensions not supported" + * return 0 # return type just used as an error flag +*/ + } + } + + /* "View.MemoryView":714 + * if suboffset >= 0: + * raise ValueError, "Indirect dimensions not supported" + * return 0 # return type just used as an error flag # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":710 + * return have_slices or nslices, tuple(result) + * + * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: # <<<<<<<<<<<<<< + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.assert_direct_dimensions", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":720 + * + * + * @cname('__pyx_memview_slice') # <<<<<<<<<<<<<< + * cdef memoryview memview_slice(memoryview memview, object indices): + * cdef int new_ndim = 0, suboffset_dim = -1, dim +*/ + +static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *__pyx_v_memview, PyObject *__pyx_v_indices) { + int __pyx_v_new_ndim; + int __pyx_v_suboffset_dim; + int __pyx_v_dim; + __Pyx_memviewslice __pyx_v_src; + __Pyx_memviewslice __pyx_v_dst; + __Pyx_memviewslice *__pyx_v_p_src; + struct __pyx_memoryviewslice_obj *__pyx_v_memviewsliceobj = 0; + __Pyx_memviewslice *__pyx_v_p_dst; + int *__pyx_v_p_suboffset_dim; + Py_ssize_t __pyx_v_start; + Py_ssize_t __pyx_v_stop; + Py_ssize_t __pyx_v_step; + Py_ssize_t __pyx_v_cindex; + int __pyx_v_have_start; + int __pyx_v_have_stop; + int __pyx_v_have_step; + PyObject *__pyx_v_index = NULL; + struct __pyx_memoryview_obj *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + struct __pyx_memoryview_obj *__pyx_t_3; + char *__pyx_t_4; + int __pyx_t_5; + Py_ssize_t __pyx_t_6; + PyObject *(*__pyx_t_7)(PyObject *); + PyObject *__pyx_t_8 = NULL; + Py_ssize_t __pyx_t_9; + int __pyx_t_10; + Py_ssize_t __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memview_slice", 0); + + /* "View.MemoryView":722 + * @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":729 + * + * + * memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<< + * + * cdef _memoryviewslice memviewsliceobj +*/ + (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst)))); + + /* "View.MemoryView":733 + * cdef _memoryviewslice memviewsliceobj + * + * assert memview.view.ndim > 0 # <<<<<<<<<<<<<< + * + * if isinstance(memview, _memoryviewslice): +*/ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = (__pyx_v_memview->view.ndim > 0); + if (unlikely(!__pyx_t_1)) { + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_AssertionError))), 0, 0, 0); + __PYX_ERR(1, 733, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(1, 733, __pyx_L1_error) + #endif + + /* "View.MemoryView":735 + * 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_mstate_global->__pyx_memoryviewslice_type); + if (__pyx_t_1) { + + /* "View.MemoryView":736 + * + * if isinstance(memview, _memoryviewslice): + * memviewsliceobj = memview # <<<<<<<<<<<<<< + * p_src = &memviewsliceobj.from_slice + * else: +*/ + __pyx_t_2 = ((PyObject *)__pyx_v_memview); + __Pyx_INCREF(__pyx_t_2); + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_mstate_global->__pyx_memoryviewslice_type))))) __PYX_ERR(1, 736, __pyx_L1_error) + __pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":737 + * 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":735 + * assert memview.view.ndim > 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":739 + * 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":740 + * else: + * slice_copy(memview, &src) + * p_src = &src # <<<<<<<<<<<<<< + * + * +*/ + __pyx_v_p_src = (&__pyx_v_src); + } + __pyx_L3:; + + /* "View.MemoryView":746 + * + * + * dst.memview = p_src.memview # <<<<<<<<<<<<<< + * dst.data = p_src.data + * +*/ + __pyx_t_3 = __pyx_v_p_src->memview; + __pyx_v_dst.memview = __pyx_t_3; + + /* "View.MemoryView":747 + * + * dst.memview = p_src.memview + * dst.data = p_src.data # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_4 = __pyx_v_p_src->data; + __pyx_v_dst.data = __pyx_t_4; + + /* "View.MemoryView":752 + * + * + * cdef __Pyx_memviewslice *p_dst = &dst # <<<<<<<<<<<<<< + * cdef int *p_suboffset_dim = &suboffset_dim + * cdef Py_ssize_t start, stop, step, cindex +*/ + __pyx_v_p_dst = (&__pyx_v_dst); + + /* "View.MemoryView":753 + * + * cdef __Pyx_memviewslice *p_dst = &dst + * cdef int *p_suboffset_dim = &suboffset_dim # <<<<<<<<<<<<<< + * cdef Py_ssize_t start, stop, step, cindex + * cdef bint have_start, have_stop, have_step +*/ + __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim); + + /* "View.MemoryView":757 + * cdef bint have_start, have_stop, have_step + * + * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< + * if PyIndex_Check(index): + * cindex = index +*/ + __pyx_t_5 = 0; + if (likely(PyList_CheckExact(__pyx_v_indices)) || PyTuple_CheckExact(__pyx_v_indices)) { + __pyx_t_2 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_2); + __pyx_t_6 = 0; + __pyx_t_7 = NULL; + } else { + __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 757, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 757, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_7)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 757, __pyx_L1_error) + #endif + if (__pyx_t_6 >= __pyx_temp) break; + } + __pyx_t_8 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_2, __pyx_t_6, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_6; + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 757, __pyx_L1_error) + #endif + if (__pyx_t_6 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6)); + #else + __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); + #endif + ++__pyx_t_6; + } + if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 757, __pyx_L1_error) + } else { + __pyx_t_8 = __pyx_t_7(__pyx_t_2); + if (unlikely(!__pyx_t_8)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(1, 757, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_8); + __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_v_dim = __pyx_t_5; + __pyx_t_5 = (__pyx_t_5 + 1); + + /* "View.MemoryView":758 + * + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): # <<<<<<<<<<<<<< + * cindex = index + * slice_memviewslice( +*/ + __pyx_t_1 = (PyIndex_Check(__pyx_v_index) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":759 + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): + * cindex = index # <<<<<<<<<<<<<< + * slice_memviewslice( + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], +*/ + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 759, __pyx_L1_error) + __pyx_v_cindex = __pyx_t_9; + + /* "View.MemoryView":760 + * if PyIndex_Check(index): + * cindex = index + * slice_memviewslice( # <<<<<<<<<<<<<< + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + * dim, new_ndim, p_suboffset_dim, +*/ + __pyx_t_10 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_cindex, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(1, 760, __pyx_L1_error) + + /* "View.MemoryView":758 + * + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): # <<<<<<<<<<<<<< + * cindex = index + * slice_memviewslice( +*/ + goto __pyx_L6; + } + + /* "View.MemoryView":766 + * 0, 0, 0, # have_{start,stop,step} + * False) + * elif index is None: # <<<<<<<<<<<<<< + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 +*/ + __pyx_t_1 = (__pyx_v_index == Py_None); + if (__pyx_t_1) { + + /* "View.MemoryView":767 + * 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":768 + * 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":769 + * 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":770 + * 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":766 + * 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":772 + * new_ndim += 1 + * else: + * start = index.start or 0 # <<<<<<<<<<<<<< + * stop = index.stop or 0 + * step = index.step or 0 +*/ + /*else*/ { + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_mstate_global->__pyx_n_u_start); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 772, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 772, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else { + __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 772, __pyx_L1_error) + __pyx_t_9 = __pyx_t_11; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_9 = 0; + __pyx_L7_bool_binop_done:; + __pyx_v_start = __pyx_t_9; + + /* "View.MemoryView":773 + * else: + * start = index.start or 0 + * stop = index.stop or 0 # <<<<<<<<<<<<<< + * step = index.step or 0 + * +*/ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_mstate_global->__pyx_n_u_stop); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 773, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 773, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else { + __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 773, __pyx_L1_error) + __pyx_t_9 = __pyx_t_11; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_9 = 0; + __pyx_L9_bool_binop_done:; + __pyx_v_stop = __pyx_t_9; + + /* "View.MemoryView":774 + * start = index.start or 0 + * stop = index.stop or 0 + * step = index.step or 0 # <<<<<<<<<<<<<< + * + * have_start = index.start is not None +*/ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_mstate_global->__pyx_n_u_step); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 774, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 774, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else { + __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 774, __pyx_L1_error) + __pyx_t_9 = __pyx_t_11; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_9 = 0; + __pyx_L11_bool_binop_done:; + __pyx_v_step = __pyx_t_9; + + /* "View.MemoryView":776 + * step = index.step or 0 + * + * have_start = index.start is not None # <<<<<<<<<<<<<< + * have_stop = index.stop is not None + * have_step = index.step is not None +*/ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_mstate_global->__pyx_n_u_start); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 776, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = (__pyx_t_8 != Py_None); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_v_have_start = __pyx_t_1; + + /* "View.MemoryView":777 + * + * have_start = index.start is not None + * have_stop = index.stop is not None # <<<<<<<<<<<<<< + * have_step = index.step is not None + * +*/ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_mstate_global->__pyx_n_u_stop); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 777, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = (__pyx_t_8 != Py_None); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_v_have_stop = __pyx_t_1; + + /* "View.MemoryView":778 + * have_start = index.start is not None + * have_stop = index.stop is not None + * have_step = index.step is not None # <<<<<<<<<<<<<< + * + * slice_memviewslice( +*/ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_mstate_global->__pyx_n_u_step); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 778, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = (__pyx_t_8 != Py_None); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_v_have_step = __pyx_t_1; + + /* "View.MemoryView":780 + * have_step = index.step is not None + * + * slice_memviewslice( # <<<<<<<<<<<<<< + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + * dim, new_ndim, p_suboffset_dim, +*/ + __pyx_t_10 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_start, __pyx_v_stop, __pyx_v_step, __pyx_v_have_start, __pyx_v_have_stop, __pyx_v_have_step, 1); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(1, 780, __pyx_L1_error) + + /* "View.MemoryView":786 + * 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":757 + * cdef bint have_start, have_stop, have_step + * + * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< + * if PyIndex_Check(index): + * cindex = index +*/ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":788 + * 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_mstate_global->__pyx_memoryviewslice_type); + if (__pyx_t_1) { + + /* "View.MemoryView":789 + * + * 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":790 + * 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, 790, __pyx_L1_error) } + + /* "View.MemoryView":791 + * 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, 791, __pyx_L1_error) } + + /* "View.MemoryView":789 + * + * if isinstance(memview, _memoryviewslice): + * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< + * memviewsliceobj.to_object_func, + * memviewsliceobj.to_dtype_func, +*/ + __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, __pyx_v_memviewsliceobj->to_object_func, __pyx_v_memviewsliceobj->to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 789, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_mstate_global->__pyx_memoryview_type))))) __PYX_ERR(1, 789, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_2); + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":788 + * new_ndim += 1 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, +*/ + } + + /* "View.MemoryView":794 + * 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":795 + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, + * memview.dtype_is_object) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 794, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "View.MemoryView":794 + * memview.dtype_is_object) + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< + * memview.dtype_is_object) + * +*/ + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_mstate_global->__pyx_memoryview_type))))) __PYX_ERR(1, 794, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_2); + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":720 + * + * + * @cname('__pyx_memview_slice') # <<<<<<<<<<<<<< + * cdef memoryview memview_slice(memoryview memview, object indices): + * cdef int new_ndim = 0, suboffset_dim = -1, dim +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("View.MemoryView.memview_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_memviewsliceobj); + __Pyx_XDECREF(__pyx_v_index); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":801 + * + * + * @cname('__pyx_pybuffer_index') # <<<<<<<<<<<<<< + * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, + * Py_ssize_t dim) except NULL: +*/ + +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[3]; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("pybuffer_index", 0); + + /* "View.MemoryView":804 + * 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":805 + * 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":808 + * cdef char *resultp + * + * if view.ndim == 0: # <<<<<<<<<<<<<< + * shape = view.len // itemsize + * stride = itemsize +*/ + __pyx_t_2 = (__pyx_v_view->ndim == 0); + if (__pyx_t_2) { + + /* "View.MemoryView":809 + * + * 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, 809, __pyx_L1_error) + } + else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(__Pyx_UNARY_NEG_WOULD_OVERFLOW(__pyx_v_view->len))) { + PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); + __PYX_ERR(1, 809, __pyx_L1_error) + } + __pyx_v_shape = __Pyx_div_Py_ssize_t(__pyx_v_view->len, __pyx_v_itemsize, 0); + + /* "View.MemoryView":810 + * if view.ndim == 0: + * shape = view.len // itemsize + * stride = itemsize # <<<<<<<<<<<<<< + * else: + * shape = view.shape[dim] +*/ + __pyx_v_stride = __pyx_v_itemsize; + + /* "View.MemoryView":808 + * cdef char *resultp + * + * if view.ndim == 0: # <<<<<<<<<<<<<< + * shape = view.len // itemsize + * stride = itemsize +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":812 + * 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":813 + * 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":814 + * shape = view.shape[dim] + * stride = view.strides[dim] + * if view.suboffsets != NULL: # <<<<<<<<<<<<<< + * suboffset = view.suboffsets[dim] + * +*/ + __pyx_t_2 = (__pyx_v_view->suboffsets != NULL); + if (__pyx_t_2) { + + /* "View.MemoryView":815 + * 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":814 + * shape = view.shape[dim] + * stride = view.strides[dim] + * if view.suboffsets != NULL: # <<<<<<<<<<<<<< + * suboffset = view.suboffsets[dim] + * +*/ + } + } + __pyx_L3:; + + /* "View.MemoryView":817 + * suboffset = view.suboffsets[dim] + * + * if index < 0: # <<<<<<<<<<<<<< + * index += view.shape[dim] + * if index < 0: +*/ + __pyx_t_2 = (__pyx_v_index < 0); + if (__pyx_t_2) { + + /* "View.MemoryView":818 + * + * if index < 0: + * index += view.shape[dim] # <<<<<<<<<<<<<< + * if index < 0: + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" +*/ + __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim])); + + /* "View.MemoryView":819 + * if index < 0: + * index += view.shape[dim] + * if index < 0: # <<<<<<<<<<<<<< + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" + * +*/ + __pyx_t_2 = (__pyx_v_index < 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":820 + * index += view.shape[dim] + * if index < 0: + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" # <<<<<<<<<<<<<< + * + * if index >= shape: +*/ + __pyx_t_3 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 820, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4[0] = __pyx_mstate_global->__pyx_kp_u_Out_of_bounds_on_buffer_access_a; + __pyx_t_4[1] = __pyx_t_3; + __pyx_t_4[2] = __pyx_mstate_global->__pyx_kp_u__5; + __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_4, 3, 37 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 1, 127); + if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 820, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_IndexError))), __pyx_t_5, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(1, 820, __pyx_L1_error) + + /* "View.MemoryView":819 + * if index < 0: + * index += view.shape[dim] + * if index < 0: # <<<<<<<<<<<<<< + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" + * +*/ + } + + /* "View.MemoryView":817 + * suboffset = view.suboffsets[dim] + * + * if index < 0: # <<<<<<<<<<<<<< + * index += view.shape[dim] + * if index < 0: +*/ + } + + /* "View.MemoryView":822 + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" + * + * if index >= shape: # <<<<<<<<<<<<<< + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" + * +*/ + __pyx_t_2 = (__pyx_v_index >= __pyx_v_shape); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":823 + * + * if index >= shape: + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" # <<<<<<<<<<<<<< + * + * resultp = bufp + index * stride +*/ + __pyx_t_5 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 823, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4[0] = __pyx_mstate_global->__pyx_kp_u_Out_of_bounds_on_buffer_access_a; + __pyx_t_4[1] = __pyx_t_5; + __pyx_t_4[2] = __pyx_mstate_global->__pyx_kp_u__5; + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_4, 3, 37 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 1, 127); + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 823, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_IndexError))), __pyx_t_3, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 823, __pyx_L1_error) + + /* "View.MemoryView":822 + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" + * + * if index >= shape: # <<<<<<<<<<<<<< + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" + * +*/ + } + + /* "View.MemoryView":825 + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" + * + * resultp = bufp + index * stride # <<<<<<<<<<<<<< + * if suboffset >= 0: + * resultp = ( resultp)[0] + suboffset +*/ + __pyx_v_resultp = (__pyx_v_bufp + (__pyx_v_index * __pyx_v_stride)); + + /* "View.MemoryView":826 + * + * resultp = bufp + index * stride + * if suboffset >= 0: # <<<<<<<<<<<<<< + * resultp = ( resultp)[0] + suboffset + * +*/ + __pyx_t_2 = (__pyx_v_suboffset >= 0); + if (__pyx_t_2) { + + /* "View.MemoryView":827 + * 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":826 + * + * resultp = bufp + index * stride + * if suboffset >= 0: # <<<<<<<<<<<<<< + * resultp = ( resultp)[0] + suboffset + * +*/ + } + + /* "View.MemoryView":829 + * resultp = ( resultp)[0] + suboffset + * + * return resultp # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = __pyx_v_resultp; + goto __pyx_L0; + + /* "View.MemoryView":801 + * + * + * @cname('__pyx_pybuffer_index') # <<<<<<<<<<<<<< + * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, + * Py_ssize_t dim) except NULL: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.pybuffer_index", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":834 + * + * + * @cname('__pyx_memslice_transpose') # <<<<<<<<<<<<<< + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil: + * cdef int ndim = memslice.memview.view.ndim +*/ + +static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { + int __pyx_v_ndim; + Py_ssize_t *__pyx_v_shape; + Py_ssize_t *__pyx_v_strides; + int __pyx_v_i; + int __pyx_v_j; + int __pyx_r; + int __pyx_t_1; + Py_ssize_t *__pyx_t_2; + long __pyx_t_3; + long __pyx_t_4; + Py_ssize_t __pyx_t_5; + Py_ssize_t __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyGILState_STATE __pyx_gilstate_save; + + /* "View.MemoryView":836 + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil: + * cdef int ndim = memslice.memview.view.ndim # <<<<<<<<<<<<<< + * + * cdef Py_ssize_t *shape = memslice.shape +*/ + __pyx_t_1 = __pyx_v_memslice->memview->view.ndim; + __pyx_v_ndim = __pyx_t_1; + + /* "View.MemoryView":838 + * 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":839 + * + * 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":843 + * + * 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, 1); + __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":844 + * 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":845 + * 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":846 + * 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":848 + * shape[i], shape[j] = shape[j], shape[i] + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< + * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") + * +*/ + __pyx_t_8 = ((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 0); + if (!__pyx_t_8) { + } else { + __pyx_t_7 = __pyx_t_8; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_8 = ((__pyx_v_memslice->suboffsets[__pyx_v_j]) >= 0); + __pyx_t_7 = __pyx_t_8; + __pyx_L6_bool_binop_done:; + if (__pyx_t_7) { + + /* "View.MemoryView":849 + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: + * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") # <<<<<<<<<<<<<< + * + * return 0 +*/ + __pyx_t_9 = __pyx_memoryview_err(PyExc_ValueError, __pyx_mstate_global->__pyx_kp_u_Cannot_transpose_memoryview_with); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 849, __pyx_L1_error) + + /* "View.MemoryView":848 + * shape[i], shape[j] = shape[j], shape[i] + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< + * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") + * +*/ + } + } + + /* "View.MemoryView":851 + * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") + * + * return 0 # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":834 + * + * + * @cname('__pyx_memslice_transpose') # <<<<<<<<<<<<<< + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil: + * cdef int ndim = memslice.memview.view.ndim +*/ + + /* function exit code */ + __pyx_L1_error:; + __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_AddTraceback("View.MemoryView.transpose_memslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_PyGILState_Release(__pyx_gilstate_save); + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":869 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) + * +*/ + +/* Python wrapper */ +static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { + + /* "View.MemoryView":870 + * + * def __dealloc__(self): + * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<< + * + * cdef convert_item_to_object(self, char *itemp): +*/ + __PYX_XCLEAR_MEMVIEW((&__pyx_v_self->from_slice), 1); + + /* "View.MemoryView":869 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) + * +*/ + + /* function exit code */ +} + +/* "View.MemoryView":872 + * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * if self.to_object_func != NULL: + * return self.to_object_func(itemp) +*/ + +static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("convert_item_to_object", 0); + + /* "View.MemoryView":873 + * + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: # <<<<<<<<<<<<<< + * return self.to_object_func(itemp) + * else: +*/ + __pyx_t_1 = (__pyx_v_self->to_object_func != NULL); + if (__pyx_t_1) { + + /* "View.MemoryView":874 + * 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, 874, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":873 + * + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: # <<<<<<<<<<<<<< + * return self.to_object_func(itemp) + * else: +*/ + } + + /* "View.MemoryView":876 + * 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, 876, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":872 + * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * if self.to_object_func != NULL: + * return self.to_object_func(itemp) +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":878 + * 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":879 + * + * cdef assign_item_from_object(self, char *itemp, object value): + * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< + * self.to_dtype_func(itemp, value) + * else: +*/ + __pyx_t_1 = (__pyx_v_self->to_dtype_func != NULL); + if (__pyx_t_1) { + + /* "View.MemoryView":880 + * 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, 880, __pyx_L1_error) + + /* "View.MemoryView":879 + * + * 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":882 + * self.to_dtype_func(itemp, value) + * else: + * memoryview.assign_item_from_object(self, itemp, value) # <<<<<<<<<<<<<< + * + * cdef _get_base(self): +*/ + /*else*/ { + __pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 882, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L3:; + + /* "View.MemoryView":878 + * 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":884 + * memoryview.assign_item_from_object(self, itemp, value) + * + * cdef _get_base(self): # <<<<<<<<<<<<<< + * return self.from_object + * +*/ + +static PyObject *__pyx_memoryviewslice__get_base(struct __pyx_memoryviewslice_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_get_base", 0); + + /* "View.MemoryView":885 + * + * cdef _get_base(self): + * return self.from_object # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->from_object); + __pyx_r = __pyx_v_self->from_object; + goto __pyx_L0; + + /* "View.MemoryView":884 + * memoryview.assign_item_from_object(self, itemp, value) + * + * cdef _get_base(self): # <<<<<<<<<<<<<< + * return self.from_object + * +*/ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf___pyx_memoryviewslice___reduce_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 3, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 3, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(1, 3, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 3, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf___pyx_memoryviewslice_2__setstate_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":904 + * pass # ignore failure, it's a minor issue + * + * @cname('__pyx_memoryview_fromslice') # <<<<<<<<<<<<<< + * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, + * int ndim, +*/ + +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 const *__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":913 + * cdef _memoryviewslice result + * + * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< + * return None + * +*/ + __pyx_t_1 = (((PyObject *)__pyx_v_memviewslice.memview) == Py_None); + if (__pyx_t_1) { + + /* "View.MemoryView":914 + * + * if memviewslice.memview == Py_None: + * return None # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "View.MemoryView":913 + * cdef _memoryviewslice result + * + * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< + * return None + * +*/ + } + + /* "View.MemoryView":919 + * + * + * result = _memoryviewslice.__new__(_memoryviewslice, None, 0, dtype_is_object) # <<<<<<<<<<<<<< + * + * result.from_slice = memviewslice +*/ + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 919, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 919, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None) != (0)) __PYX_ERR(1, 919, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(1, 919, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2) != (0)) __PYX_ERR(1, 919, __pyx_L1_error); + __pyx_t_2 = 0; + __pyx_t_2 = ((PyObject *)__pyx_tp_new__memoryviewslice(((PyTypeObject *)__pyx_mstate_global->__pyx_memoryviewslice_type), __pyx_t_3, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 919, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":921 + * result = _memoryviewslice.__new__(_memoryviewslice, None, 0, dtype_is_object) + * + * result.from_slice = memviewslice # <<<<<<<<<<<<<< + * __PYX_INC_MEMVIEW(&memviewslice, 1) + * +*/ + __pyx_v_result->from_slice = __pyx_v_memviewslice; + + /* "View.MemoryView":922 + * + * result.from_slice = memviewslice + * __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<< + * + * result.from_object = ( memviewslice.memview)._get_base() +*/ + __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1); + + /* "View.MemoryView":924 + * __PYX_INC_MEMVIEW(&memviewslice, 1) + * + * result.from_object = ( memviewslice.memview)._get_base() # <<<<<<<<<<<<<< + * result.typeinfo = memviewslice.memview.typeinfo + * +*/ + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->__pyx_vtab)->_get_base(((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 924, __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":925 + * + * result.from_object = ( memviewslice.memview)._get_base() + * result.typeinfo = memviewslice.memview.typeinfo # <<<<<<<<<<<<<< + * + * result.view = memviewslice.memview.view +*/ + __pyx_t_4 = __pyx_v_memviewslice.memview->typeinfo; + __pyx_v_result->__pyx_base.typeinfo = __pyx_t_4; + + /* "View.MemoryView":927 + * 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":928 + * + * 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":929 + * 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":930 + * 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":931 + * 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":933 + * 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":934 + * + * 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":933 + * Py_INCREF(Py_None) + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< + * result.flags = PyBUF_RECORDS + * else: +*/ + goto __pyx_L4; + } + + /* "View.MemoryView":936 + * 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":938 + * 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":939 + * + * 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":942 + * + * + * 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":943 + * + * 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":944 + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * result.view.suboffsets = result.from_slice.suboffsets + * break +*/ + __pyx_t_1 = (__pyx_v_suboffset >= 0); + if (__pyx_t_1) { + + /* "View.MemoryView":945 + * 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":946 + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets + * break # <<<<<<<<<<<<<< + * + * result.view.len = result.view.itemsize +*/ + goto __pyx_L6_break; + + /* "View.MemoryView":944 + * 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":948 + * 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":949 + * + * 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 = PyLong_FromSsize_t((__pyx_t_6[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 949, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":950 + * 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 = PyLong_FromSsize_t(__pyx_v_result->__pyx_base.view.len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 950, __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, 950, __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, 950, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result->__pyx_base.view.len = __pyx_t_9; + } + + /* "View.MemoryView":952 + * 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":953 + * + * 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":955 + * 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":904 + * pass # ignore failure, it's a minor issue + * + * @cname('__pyx_memoryview_fromslice') # <<<<<<<<<<<<<< + * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, + * int ndim, +*/ + + /* 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":957 + * return result + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, + * __Pyx_memviewslice *mslice) except NULL: +*/ + +static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_mslice) { + struct __pyx_memoryviewslice_obj *__pyx_v_obj = 0; + __Pyx_memviewslice *__pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_slice_from_memview", 0); + + /* "View.MemoryView":961 + * __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_mstate_global->__pyx_memoryviewslice_type); + if (__pyx_t_1) { + + /* "View.MemoryView":962 + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): + * obj = memview # <<<<<<<<<<<<<< + * return &obj.from_slice + * else: +*/ + __pyx_t_2 = ((PyObject *)__pyx_v_memview); + __Pyx_INCREF(__pyx_t_2); + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_mstate_global->__pyx_memoryviewslice_type))))) __PYX_ERR(1, 962, __pyx_L1_error) + __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":963 + * 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":961 + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * obj = memview + * return &obj.from_slice +*/ + } + + /* "View.MemoryView":965 + * return &obj.from_slice + * else: + * slice_copy(memview, mslice) # <<<<<<<<<<<<<< + * return mslice + * +*/ + /*else*/ { + __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice); + + /* "View.MemoryView":966 + * else: + * slice_copy(memview, mslice) + * return mslice # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_slice_copy') +*/ + __pyx_r = __pyx_v_mslice; + goto __pyx_L0; + } + + /* "View.MemoryView":957 + * return result + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, + * __Pyx_memviewslice *mslice) except NULL: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.get_slice_from_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_obj); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":968 + * return mslice + * + * @cname('__pyx_memoryview_slice_copy') # <<<<<<<<<<<<<< + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst) noexcept: + * cdef int dim +*/ + +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; + Py_ssize_t *__pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + Py_ssize_t __pyx_t_5; + int __pyx_t_6; + + /* "View.MemoryView":973 + * 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":974 + * + * 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":975 + * 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":977 + * 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":978 + * + * 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":980 + * 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":981 + * + * 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":982 + * 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":983 + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_object') +*/ + __pyx_t_6 = (__pyx_v_suboffsets != 0); + if (__pyx_t_6) { + __pyx_t_5 = (__pyx_v_suboffsets[__pyx_v_dim]); + } else { + __pyx_t_5 = -1L; + } + (__pyx_v_dst->suboffsets[__pyx_v_dim]) = __pyx_t_5; + } + + /* "View.MemoryView":968 + * return mslice + * + * @cname('__pyx_memoryview_slice_copy') # <<<<<<<<<<<<<< + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst) noexcept: + * cdef int dim +*/ + + /* function exit code */ +} + +/* "View.MemoryView":985 + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 + * + * @cname('__pyx_memoryview_copy_object') # <<<<<<<<<<<<<< + * cdef memoryview_copy(memoryview memview): + * "Create a new memoryview object" +*/ + +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":989 + * "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":990 + * 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, 990, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":985 + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 + * + * @cname('__pyx_memoryview_copy_object') # <<<<<<<<<<<<<< + * cdef memoryview_copy(memoryview memview): + * "Create a new memoryview object" +*/ + + /* 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":992 + * return memoryview_copy_from_slice(memview, &memviewslice) + * + * @cname('__pyx_memoryview_copy_object_from_slice') # <<<<<<<<<<<<<< + * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): + * """ +*/ + +static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_memviewslice) { + PyObject *(*__pyx_v_to_object_func)(char *); + int (*__pyx_v_to_dtype_func)(char *, PyObject *); + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *(*__pyx_t_2)(char *); + int (*__pyx_t_3)(char *, PyObject *); + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 0); + + /* "View.MemoryView":1000 + * 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_mstate_global->__pyx_memoryviewslice_type); + if (__pyx_t_1) { + + /* "View.MemoryView":1001 + * + * if isinstance(memview, _memoryviewslice): + * to_object_func = (<_memoryviewslice> memview).to_object_func # <<<<<<<<<<<<<< + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + * else: +*/ + __pyx_t_2 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func; + __pyx_v_to_object_func = __pyx_t_2; + + /* "View.MemoryView":1002 + * if isinstance(memview, _memoryviewslice): + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func # <<<<<<<<<<<<<< + * else: + * to_object_func = NULL +*/ + __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func; + __pyx_v_to_dtype_func = __pyx_t_3; + + /* "View.MemoryView":1000 + * 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":1004 + * 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":1005 + * 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":1007 + * 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":1009 + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, + * to_object_func, to_dtype_func, + * memview.dtype_is_object) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_4 = __pyx_memoryview_fromslice((__pyx_v_memviewslice[0]), __pyx_v_memview->view.ndim, __pyx_v_to_object_func, __pyx_v_to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1007, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "View.MemoryView":992 + * return memoryview_copy_from_slice(memview, &memviewslice) + * + * @cname('__pyx_memoryview_copy_object_from_slice') # <<<<<<<<<<<<<< + * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): + * """ +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView.memoryview_copy_from_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1015 + * + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: # <<<<<<<<<<<<<< + * return -arg if arg < 0 else arg + * +*/ + +static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { + Py_ssize_t __pyx_r; + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + + /* "View.MemoryView":1016 + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: + * return -arg if arg < 0 else arg # <<<<<<<<<<<<<< + * + * @cname('__pyx_get_best_slice_order') +*/ + __pyx_t_2 = (__pyx_v_arg < 0); + if (__pyx_t_2) { + __pyx_t_1 = (-__pyx_v_arg); + } else { + __pyx_t_1 = __pyx_v_arg; + } + __pyx_r = __pyx_t_1; + goto __pyx_L0; + + /* "View.MemoryView":1015 + * + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: # <<<<<<<<<<<<<< + * return -arg if arg < 0 else arg + * +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1018 + * return -arg if arg < 0 else arg + * + * @cname('__pyx_get_best_slice_order') # <<<<<<<<<<<<<< + * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) noexcept nogil: + * """ +*/ + +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":1024 + * """ + * cdef int i + * cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<< + * cdef Py_ssize_t f_stride = 0 + * +*/ + __pyx_v_c_stride = 0; + + /* "View.MemoryView":1025 + * 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":1027 + * 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":1028 + * + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * c_stride = mslice.strides[i] + * break +*/ + __pyx_t_2 = ((__pyx_v_mslice->shape[__pyx_v_i]) > 1); + if (__pyx_t_2) { + + /* "View.MemoryView":1029 + * 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":1030 + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] + * break # <<<<<<<<<<<<<< + * + * for i in range(ndim): +*/ + goto __pyx_L4_break; + + /* "View.MemoryView":1028 + * + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * c_stride = mslice.strides[i] + * break +*/ + } + } + __pyx_L4_break:; + + /* "View.MemoryView":1032 + * 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":1033 + * + * for i in range(ndim): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * f_stride = mslice.strides[i] + * break +*/ + __pyx_t_2 = ((__pyx_v_mslice->shape[__pyx_v_i]) > 1); + if (__pyx_t_2) { + + /* "View.MemoryView":1034 + * 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":1035 + * 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":1033 + * + * for i in range(ndim): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * f_stride = mslice.strides[i] + * break +*/ + } + } + __pyx_L7_break:; + + /* "View.MemoryView":1037 + * break + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< + * return 'C' + * else: +*/ + __pyx_t_2 = (abs_py_ssize_t(__pyx_v_c_stride) <= abs_py_ssize_t(__pyx_v_f_stride)); + if (__pyx_t_2) { + + /* "View.MemoryView":1038 + * + * 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":1037 + * break + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< + * return 'C' + * else: +*/ + } + + /* "View.MemoryView":1040 + * return 'C' + * else: + * return 'F' # <<<<<<<<<<<<<< + * + * @cython.cdivision(True) +*/ + /*else*/ { + __pyx_r = 'F'; + goto __pyx_L0; + } + + /* "View.MemoryView":1018 + * return -arg if arg < 0 else arg + * + * @cname('__pyx_get_best_slice_order') # <<<<<<<<<<<<<< + * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) noexcept nogil: + * """ +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1042 + * return 'F' + * + * @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, +*/ + +static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v_src_strides, char *__pyx_v_dst_data, Py_ssize_t *__pyx_v_dst_strides, Py_ssize_t *__pyx_v_src_shape, Py_ssize_t *__pyx_v_dst_shape, int __pyx_v_ndim, size_t __pyx_v_itemsize) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + CYTHON_UNUSED Py_ssize_t __pyx_v_src_extent; + Py_ssize_t __pyx_v_dst_extent; + Py_ssize_t __pyx_v_src_stride; + Py_ssize_t __pyx_v_dst_stride; + int __pyx_t_1; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + + /* "View.MemoryView":1050 + * + * 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":1051 + * 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":1052 + * 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":1053 + * 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":1055 + * cdef Py_ssize_t dst_stride = dst_strides[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): +*/ + __pyx_t_1 = (__pyx_v_ndim == 1); + if (__pyx_t_1) { + + /* "View.MemoryView":1056 + * + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) +*/ + __pyx_t_2 = (__pyx_v_src_stride > 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L5_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_dst_stride > 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L5_bool_binop_done; + } + + /* "View.MemoryView":1057 + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): # <<<<<<<<<<<<<< + * memcpy(dst_data, src_data, itemsize * dst_extent) + * else: +*/ + __pyx_t_2 = (((size_t)__pyx_v_src_stride) == __pyx_v_itemsize); + if (__pyx_t_2) { + __pyx_t_2 = (__pyx_v_itemsize == ((size_t)__pyx_v_dst_stride)); + } + __pyx_t_1 = __pyx_t_2; + __pyx_L5_bool_binop_done:; + + /* "View.MemoryView":1056 + * + * 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":1058 + * 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":1056 + * + * 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":1060 + * memcpy(dst_data, src_data, itemsize * dst_extent) + * else: + * for i in range(dst_extent): # <<<<<<<<<<<<<< + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride +*/ + /*else*/ { + __pyx_t_3 = __pyx_v_dst_extent; + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "View.MemoryView":1061 + * 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":1062 + * 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":1063 + * 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":1055 + * 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":1065 + * dst_data += dst_stride + * else: + * for i in range(dst_extent): # <<<<<<<<<<<<<< + * _copy_strided_to_strided(src_data, src_strides + 1, + * dst_data, dst_strides + 1, +*/ + /*else*/ { + __pyx_t_3 = __pyx_v_dst_extent; + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "View.MemoryView":1066 + * 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":1070 + * 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":1071 + * 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":1042 + * return 'F' + * + * @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, +*/ + + /* function exit code */ +} + +/* "View.MemoryView":1073 + * dst_data += dst_stride + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) noexcept nogil: +*/ + +static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize) { + + /* "View.MemoryView":1076 + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) noexcept nogil: + * _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides, # <<<<<<<<<<<<<< + * src.shape, dst.shape, ndim, itemsize) + * +*/ + _copy_strided_to_strided(__pyx_v_src->data, __pyx_v_src->strides, __pyx_v_dst->data, __pyx_v_dst->strides, __pyx_v_src->shape, __pyx_v_dst->shape, __pyx_v_ndim, __pyx_v_itemsize); + + /* "View.MemoryView":1073 + * dst_data += dst_stride + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) noexcept nogil: +*/ + + /* function exit code */ +} + +/* "View.MemoryView":1079 + * src.shape, dst.shape, ndim, itemsize) + * + * @cname('__pyx_memoryview_slice_get_size') # <<<<<<<<<<<<<< + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept nogil: + * "Return the size of the memory occupied by the slice in number of bytes" +*/ + +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":1082 + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept nogil: + * "Return the size of the memory occupied by the slice in number of bytes" + * cdef Py_ssize_t shape, size = src.memview.view.itemsize # <<<<<<<<<<<<<< + * + * for shape in src.shape[:ndim]: +*/ + __pyx_t_1 = __pyx_v_src->memview->view.itemsize; + __pyx_v_size = __pyx_t_1; + + /* "View.MemoryView":1084 + * 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":1085 + * + * for shape in src.shape[:ndim]: + * size *= shape # <<<<<<<<<<<<<< + * + * return size +*/ + __pyx_v_size = (__pyx_v_size * __pyx_v_shape); + } + + /* "View.MemoryView":1087 + * size *= shape + * + * return size # <<<<<<<<<<<<<< + * + * @cname('__pyx_fill_contig_strides_array') +*/ + __pyx_r = __pyx_v_size; + goto __pyx_L0; + + /* "View.MemoryView":1079 + * src.shape, dst.shape, ndim, itemsize) + * + * @cname('__pyx_memoryview_slice_get_size') # <<<<<<<<<<<<<< + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept nogil: + * "Return the size of the memory occupied by the slice in number of bytes" +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1089 + * return size + * + * @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, +*/ + +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":1099 + * cdef int idx + * + * if order == 'F': # <<<<<<<<<<<<<< + * for idx in range(ndim): + * strides[idx] = stride +*/ + __pyx_t_1 = (__pyx_v_order == 'F'); + if (__pyx_t_1) { + + /* "View.MemoryView":1100 + * + * 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":1101 + * 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":1102 + * 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":1099 + * cdef int idx + * + * if order == 'F': # <<<<<<<<<<<<<< + * for idx in range(ndim): + * strides[idx] = stride +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":1104 + * 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":1105 + * 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":1106 + * 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":1108 + * stride *= shape[idx] + * + * return stride # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_data_to_temp') +*/ + __pyx_r = __pyx_v_stride; + goto __pyx_L0; + + /* "View.MemoryView":1089 + * return size + * + * @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, +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1110 + * return stride + * + * @cname('__pyx_memoryview_copy_data_to_temp') # <<<<<<<<<<<<<< + * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, + * __Pyx_memviewslice *tmpslice, +*/ + +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; + PyGILState_STATE __pyx_gilstate_save; + + /* "View.MemoryView":1122 + * 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":1123 + * + * 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":1125 + * cdef size_t size = slice_get_size(src, ndim) + * + * result = malloc(size) # <<<<<<<<<<<<<< + * if not result: + * _err_no_memory() +*/ + __pyx_v_result = malloc(__pyx_v_size); + + /* "View.MemoryView":1126 + * + * result = malloc(size) + * if not result: # <<<<<<<<<<<<<< + * _err_no_memory() + * +*/ + __pyx_t_2 = (!(__pyx_v_result != 0)); + if (__pyx_t_2) { + + /* "View.MemoryView":1127 + * result = malloc(size) + * if not result: + * _err_no_memory() # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_3 = __pyx_memoryview_err_no_memory(); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 1127, __pyx_L1_error) + + /* "View.MemoryView":1126 + * + * result = malloc(size) + * if not result: # <<<<<<<<<<<<<< + * _err_no_memory() + * +*/ + } + + /* "View.MemoryView":1130 + * + * + * tmpslice.data = result # <<<<<<<<<<<<<< + * tmpslice.memview = src.memview + * for i in range(ndim): +*/ + __pyx_v_tmpslice->data = ((char *)__pyx_v_result); + + /* "View.MemoryView":1131 + * + * 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":1132 + * 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":1133 + * 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":1134 + * for i in range(ndim): + * tmpslice.shape[i] = src.shape[i] + * tmpslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< + * + * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, ndim, order) +*/ + (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L; + } + + /* "View.MemoryView":1136 + * 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":1139 + * + * + * 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":1140 + * + * for i in range(ndim): + * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< + * tmpslice.strides[i] = 0 + * +*/ + __pyx_t_2 = ((__pyx_v_tmpslice->shape[__pyx_v_i]) == 1); + if (__pyx_t_2) { + + /* "View.MemoryView":1141 + * 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":1140 + * + * for i in range(ndim): + * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< + * tmpslice.strides[i] = 0 + * +*/ + } + } + + /* "View.MemoryView":1143 + * tmpslice.strides[i] = 0 + * + * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< + * memcpy(result, src.data, size) + * else: +*/ + __pyx_t_2 = __pyx_memviewslice_is_contig((__pyx_v_src[0]), __pyx_v_order, __pyx_v_ndim); + if (__pyx_t_2) { + + /* "View.MemoryView":1144 + * + * 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":1143 + * tmpslice.strides[i] = 0 + * + * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< + * memcpy(result, src.data, size) + * else: +*/ + goto __pyx_L9; + } + + /* "View.MemoryView":1146 + * 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":1148 + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) + * + * return result # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "View.MemoryView":1110 + * return stride + * + * @cname('__pyx_memoryview_copy_data_to_temp') # <<<<<<<<<<<<<< + * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, + * __Pyx_memviewslice *tmpslice, +*/ + + /* function exit code */ + __pyx_L1_error:; + __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_AddTraceback("View.MemoryView.copy_data_to_temp", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_PyGILState_Release(__pyx_gilstate_save); + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1152 + * + * + * @cname('__pyx_memoryview_err_extents') # <<<<<<<<<<<<<< + * cdef int _err_extents(int i, Py_ssize_t extent1, + * Py_ssize_t extent2) except -1 with gil: +*/ + +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[7]; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_RefNannySetupContext("_err_extents", 0); + + /* "View.MemoryView":1155 + * cdef int _err_extents(int i, Py_ssize_t extent1, + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError, f"got differing extents in dimension {i} (got {extent1} and {extent2})" # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_err_dim') +*/ + __pyx_t_1 = __Pyx_PyUnicode_From_int(__pyx_v_i, 0, ' ', 'd'); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_extent1, 0, ' ', 'd'); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_extent2, 0, ' ', 'd'); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4[0] = __pyx_mstate_global->__pyx_kp_u_got_differing_extents_in_dimensi; + __pyx_t_4[1] = __pyx_t_1; + __pyx_t_4[2] = __pyx_mstate_global->__pyx_kp_u_got; + __pyx_t_4[3] = __pyx_t_2; + __pyx_t_4[4] = __pyx_mstate_global->__pyx_kp_u_and; + __pyx_t_4[5] = __pyx_t_3; + __pyx_t_4[6] = __pyx_mstate_global->__pyx_kp_u__5; + __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_4, 7, 35 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 6 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 5 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 1, 127); + if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_ValueError))), __pyx_t_5, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(1, 1155, __pyx_L1_error) + + /* "View.MemoryView":1152 + * + * + * @cname('__pyx_memoryview_err_extents') # <<<<<<<<<<<<<< + * cdef int _err_extents(int i, Py_ssize_t extent1, + * Py_ssize_t extent2) except -1 with gil: +*/ + + /* 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_5); + __Pyx_AddTraceback("View.MemoryView._err_extents", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + __Pyx_PyGILState_Release(__pyx_gilstate_save); + return __pyx_r; +} + +/* "View.MemoryView":1157 + * raise ValueError, f"got differing extents in dimension {i} (got {extent1} and {extent2})" + * + * @cname('__pyx_memoryview_err_dim') # <<<<<<<<<<<<<< + * cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil: + * raise error, msg % dim +*/ + +static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, PyObject *__pyx_v_msg, int __pyx_v_dim) { + int __pyx_r; + __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; + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_RefNannySetupContext("_err_dim", 0); + __Pyx_INCREF(__pyx_v_msg); + + /* "View.MemoryView":1159 + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil: + * raise error, msg % dim # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_err') +*/ + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyUnicode_FormatSafe(__pyx_v_msg, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(((PyObject *)__pyx_v_error), __pyx_t_2, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 1159, __pyx_L1_error) + + /* "View.MemoryView":1157 + * raise ValueError, f"got differing extents in dimension {i} (got {extent1} and {extent2})" + * + * @cname('__pyx_memoryview_err_dim') # <<<<<<<<<<<<<< + * cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil: + * raise error, msg % dim +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView._err_dim", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_XDECREF(__pyx_v_msg); + __Pyx_RefNannyFinishContext(); + __Pyx_PyGILState_Release(__pyx_gilstate_save); + return __pyx_r; +} + +/* "View.MemoryView":1161 + * raise error, msg % dim + * + * @cname('__pyx_memoryview_err') # <<<<<<<<<<<<<< + * cdef int _err(PyObject *error, str msg) except -1 with gil: + * raise error, msg +*/ + +static int __pyx_memoryview_err(PyObject *__pyx_v_error, PyObject *__pyx_v_msg) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_RefNannySetupContext("_err", 0); + __Pyx_INCREF(__pyx_v_msg); + + /* "View.MemoryView":1163 + * @cname('__pyx_memoryview_err') + * cdef int _err(PyObject *error, str msg) except -1 with gil: + * raise error, msg # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_err_no_memory') +*/ + __Pyx_Raise(((PyObject *)__pyx_v_error), __pyx_v_msg, 0, 0); + __PYX_ERR(1, 1163, __pyx_L1_error) + + /* "View.MemoryView":1161 + * raise error, msg % dim + * + * @cname('__pyx_memoryview_err') # <<<<<<<<<<<<<< + * cdef int _err(PyObject *error, str msg) except -1 with gil: + * raise error, msg +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView._err", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_XDECREF(__pyx_v_msg); + __Pyx_RefNannyFinishContext(); + __Pyx_PyGILState_Release(__pyx_gilstate_save); + return __pyx_r; +} + +/* "View.MemoryView":1165 + * raise error, msg + * + * @cname('__pyx_memoryview_err_no_memory') # <<<<<<<<<<<<<< + * cdef int _err_no_memory() except -1 with gil: + * raise MemoryError +*/ + +static int __pyx_memoryview_err_no_memory(void) { + int __pyx_r; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + + /* "View.MemoryView":1167 + * @cname('__pyx_memoryview_err_no_memory') + * cdef int _err_no_memory() except -1 with gil: + * raise MemoryError # <<<<<<<<<<<<<< + * + * +*/ + PyErr_NoMemory(); __PYX_ERR(1, 1167, __pyx_L1_error) + + /* "View.MemoryView":1165 + * raise error, msg + * + * @cname('__pyx_memoryview_err_no_memory') # <<<<<<<<<<<<<< + * cdef int _err_no_memory() except -1 with gil: + * raise MemoryError +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView._err_no_memory", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_PyGILState_Release(__pyx_gilstate_save); + return __pyx_r; +} + +/* "View.MemoryView":1170 + * + * + * @cname('__pyx_memoryview_copy_contents') # <<<<<<<<<<<<<< + * cdef int memoryview_copy_contents(__Pyx_memviewslice src, + * __Pyx_memviewslice dst, +*/ + +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_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyGILState_STATE __pyx_gilstate_save; + + /* "View.MemoryView":1179 + * 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":1180 + * """ + * 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":1182 + * 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":1183 + * 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":1184 + * 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":1187 + * 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); + if (__pyx_t_2) { + + /* "View.MemoryView":1188 + * + * 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":1187 + * 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":1189 + * 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); + if (__pyx_t_2) { + + /* "View.MemoryView":1190 + * 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":1189 + * 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":1192 + * 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; + __pyx_t_2 = (__pyx_t_3 > __pyx_t_4); + if (__pyx_t_2) { + __pyx_t_5 = __pyx_t_3; + } else { + __pyx_t_5 = __pyx_t_4; + } + __pyx_v_ndim = __pyx_t_5; + + /* "View.MemoryView":1194 + * 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":1195 + * + * 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])); + if (__pyx_t_2) { + + /* "View.MemoryView":1196 + * 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); + if (__pyx_t_2) { + + /* "View.MemoryView":1197 + * 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":1198 + * 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":1196 + * 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":1200 + * 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, 1200, __pyx_L1_error) + } + __pyx_L7:; + + /* "View.MemoryView":1195 + * + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< + * if src.shape[i] == 1: + * broadcasting = True +*/ + } + + /* "View.MemoryView":1202 + * _err_extents(i, dst.shape[i], src.shape[i]) + * + * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< + * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) + * +*/ + __pyx_t_2 = ((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1203 + * + * if src.suboffsets[i] >= 0: + * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) # <<<<<<<<<<<<<< + * + * if slices_overlap(&src, &dst, ndim, itemsize): +*/ + __pyx_t_6 = __pyx_memoryview_err_dim(PyExc_ValueError, __pyx_mstate_global->__pyx_kp_u_Dimension_d_is_not_direct, __pyx_v_i); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1203, __pyx_L1_error) + + /* "View.MemoryView":1202 + * _err_extents(i, dst.shape[i], src.shape[i]) + * + * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< + * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) + * +*/ + } + } + + /* "View.MemoryView":1205 + * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) + * + * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< + * + * if not slice_is_contig(src, order, ndim): +*/ + __pyx_t_2 = __pyx_slices_overlap((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); + if (__pyx_t_2) { + + /* "View.MemoryView":1207 + * 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)); + if (__pyx_t_2) { + + /* "View.MemoryView":1208 + * + * 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":1207 + * if slices_overlap(&src, &dst, ndim, itemsize): + * + * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< + * order = get_best_order(&dst, ndim) + * +*/ + } + + /* "View.MemoryView":1210 + * 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, 1210, __pyx_L1_error) + __pyx_v_tmpdata = __pyx_t_7; + + /* "View.MemoryView":1211 + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) + * src = tmp # <<<<<<<<<<<<<< + * + * if not broadcasting: +*/ + __pyx_v_src = __pyx_v_tmp; + + /* "View.MemoryView":1205 + * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) + * + * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< + * + * if not slice_is_contig(src, order, ndim): +*/ + } + + /* "View.MemoryView":1213 + * src = tmp + * + * if not broadcasting: # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_2 = (!__pyx_v_broadcasting); + if (__pyx_t_2) { + + /* "View.MemoryView":1216 + * + * + * 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); + if (__pyx_t_2) { + + /* "View.MemoryView":1217 + * + * 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":1216 + * + * + * 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":1218 + * 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); + if (__pyx_t_2) { + + /* "View.MemoryView":1219 + * 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":1218 + * 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":1221 + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + * if direct_copy: # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) +*/ + if (__pyx_v_direct_copy) { + + /* "View.MemoryView":1223 + * if direct_copy: + * + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) # <<<<<<<<<<<<<< + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) +*/ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1224 + * + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) + * free(tmpdata) +*/ + (void)(memcpy(__pyx_v_dst.data, __pyx_v_src.data, __pyx_memoryview_slice_get_size((&__pyx_v_src), __pyx_v_ndim))); + + /* "View.MemoryView":1225 + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) # <<<<<<<<<<<<<< + * free(tmpdata) + * return 0 +*/ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1226 + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) + * free(tmpdata) # <<<<<<<<<<<<<< + * return 0 + * +*/ + free(__pyx_v_tmpdata); + + /* "View.MemoryView":1227 + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) + * free(tmpdata) + * return 0 # <<<<<<<<<<<<<< + * + * if order == 'F' == get_best_order(&dst, ndim): +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":1221 + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + * if direct_copy: # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) +*/ + } + + /* "View.MemoryView":1213 + * src = tmp + * + * if not broadcasting: # <<<<<<<<<<<<<< + * + * +*/ + } + + /* "View.MemoryView":1229 + * 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)); + } + if (__pyx_t_2) { + + /* "View.MemoryView":1232 + * + * + * transpose_memslice(&src) # <<<<<<<<<<<<<< + * transpose_memslice(&dst) + * +*/ + __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_src)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 1232, __pyx_L1_error) + + /* "View.MemoryView":1233 + * + * transpose_memslice(&src) + * transpose_memslice(&dst) # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) +*/ + __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_dst)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 1233, __pyx_L1_error) + + /* "View.MemoryView":1229 + * return 0 + * + * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< + * + * +*/ + } + + /* "View.MemoryView":1235 + * transpose_memslice(&dst) + * + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) # <<<<<<<<<<<<<< + * copy_strided_to_strided(&src, &dst, ndim, itemsize) + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) +*/ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1236 + * + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) + * copy_strided_to_strided(&src, &dst, ndim, itemsize) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) + * +*/ + copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); + + /* "View.MemoryView":1237 + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) + * copy_strided_to_strided(&src, &dst, ndim, itemsize) + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) # <<<<<<<<<<<<<< + * + * free(tmpdata) +*/ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1239 + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) + * + * free(tmpdata) # <<<<<<<<<<<<<< + * return 0 + * +*/ + free(__pyx_v_tmpdata); + + /* "View.MemoryView":1240 + * + * free(tmpdata) + * return 0 # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_broadcast_leading') +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":1170 + * + * + * @cname('__pyx_memoryview_copy_contents') # <<<<<<<<<<<<<< + * cdef int memoryview_copy_contents(__Pyx_memviewslice src, + * __Pyx_memviewslice dst, +*/ + + /* function exit code */ + __pyx_L1_error:; + __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_AddTraceback("View.MemoryView.memoryview_copy_contents", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_PyGILState_Release(__pyx_gilstate_save); + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1242 + * return 0 + * + * @cname('__pyx_memoryview_broadcast_leading') # <<<<<<<<<<<<<< + * cdef void broadcast_leading(__Pyx_memviewslice *mslice, + * int ndim, +*/ + +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":1247 + * int ndim_other) noexcept 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":1249 + * 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":1250 + * + * 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":1251 + * 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":1252 + * 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":1254 + * 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":1255 + * + * 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":1256 + * 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":1257 + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] + * mslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< + * + * +*/ + (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L; + } + + /* "View.MemoryView":1242 + * return 0 + * + * @cname('__pyx_memoryview_broadcast_leading') # <<<<<<<<<<<<<< + * cdef void broadcast_leading(__Pyx_memviewslice *mslice, + * int ndim, +*/ + + /* function exit code */ +} + +/* "View.MemoryView":1264 + * + * + * @cname('__pyx_memoryview_refcount_copying') # <<<<<<<<<<<<<< + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept 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) { + + /* "View.MemoryView":1267 + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: + * + * if dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) + * +*/ + if (__pyx_v_dtype_is_object) { + + /* "View.MemoryView":1268 + * + * if dtype_is_object: + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') +*/ + __pyx_memoryview_refcount_objects_in_slice_with_gil(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_inc); + + /* "View.MemoryView":1267 + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: + * + * if dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) + * +*/ + } + + /* "View.MemoryView":1264 + * + * + * @cname('__pyx_memoryview_refcount_copying') # <<<<<<<<<<<<<< + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: + * +*/ + + /* function exit code */ +} + +/* "View.MemoryView":1270 + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) + * + * @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, +*/ + +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) { + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + + /* "View.MemoryView":1274 + * Py_ssize_t *strides, int ndim, + * bint inc) noexcept with gil: + * refcount_objects_in_slice(data, shape, strides, ndim, inc) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') +*/ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, __pyx_v_shape, __pyx_v_strides, __pyx_v_ndim, __pyx_v_inc); + + /* "View.MemoryView":1270 + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) + * + * @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, +*/ + + /* function exit code */ + __Pyx_PyGILState_Release(__pyx_gilstate_save); +} + +/* "View.MemoryView":1276 + * refcount_objects_in_slice(data, shape, strides, ndim, inc) + * + * @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) noexcept: +*/ + +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; + Py_ssize_t __pyx_v_stride; + Py_ssize_t __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + + /* "View.MemoryView":1280 + * Py_ssize_t *strides, int ndim, bint inc) noexcept: + * cdef Py_ssize_t i + * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< + * + * for i in range(shape[0]): +*/ + __pyx_v_stride = (__pyx_v_strides[0]); + + /* "View.MemoryView":1282 + * cdef Py_ssize_t stride = strides[0] + * + * 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":1283 + * + * for i in range(shape[0]): + * if ndim == 1: # <<<<<<<<<<<<<< + * if inc: + * Py_INCREF(( data)[0]) +*/ + __pyx_t_4 = (__pyx_v_ndim == 1); + if (__pyx_t_4) { + + /* "View.MemoryView":1284 + * for i in range(shape[0]): + * if ndim == 1: + * if inc: # <<<<<<<<<<<<<< + * Py_INCREF(( data)[0]) + * else: +*/ + if (__pyx_v_inc) { + + /* "View.MemoryView":1285 + * if ndim == 1: + * if inc: + * Py_INCREF(( data)[0]) # <<<<<<<<<<<<<< + * else: + * Py_DECREF(( data)[0]) +*/ + Py_INCREF((((PyObject **)__pyx_v_data)[0])); + + /* "View.MemoryView":1284 + * for i in range(shape[0]): + * if ndim == 1: + * if inc: # <<<<<<<<<<<<<< + * Py_INCREF(( data)[0]) + * else: +*/ + goto __pyx_L6; + } + + /* "View.MemoryView":1287 + * Py_INCREF(( data)[0]) + * else: + * Py_DECREF(( data)[0]) # <<<<<<<<<<<<<< + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, ndim - 1, inc) +*/ + /*else*/ { + Py_DECREF((((PyObject **)__pyx_v_data)[0])); + } + __pyx_L6:; + + /* "View.MemoryView":1283 + * + * for i in range(shape[0]): + * if ndim == 1: # <<<<<<<<<<<<<< + * if inc: + * Py_INCREF(( data)[0]) +*/ + goto __pyx_L5; + } + + /* "View.MemoryView":1289 + * Py_DECREF(( data)[0]) + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, ndim - 1, inc) # <<<<<<<<<<<<<< + * + * data += stride +*/ + /*else*/ { + __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":1291 + * refcount_objects_in_slice(data, shape + 1, strides + 1, ndim - 1, inc) + * + * data += stride # <<<<<<<<<<<<<< + * + * +*/ + __pyx_v_data = (__pyx_v_data + __pyx_v_stride); + } + + /* "View.MemoryView":1276 + * refcount_objects_in_slice(data, shape, strides, ndim, inc) + * + * @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) noexcept: +*/ + + /* function exit code */ +} + +/* "View.MemoryView":1296 + * + * + * @cname('__pyx_memoryview_slice_assign_scalar') # <<<<<<<<<<<<<< + * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, + * size_t itemsize, void *item, +*/ + +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":1300 + * size_t itemsize, void *item, + * bint dtype_is_object) noexcept nogil: + * refcount_copying(dst, dtype_is_object, ndim, inc=False) # <<<<<<<<<<<<<< + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, itemsize, item) + * refcount_copying(dst, dtype_is_object, ndim, inc=True) +*/ + __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1301 + * bint dtype_is_object) noexcept nogil: + * refcount_copying(dst, dtype_is_object, ndim, inc=False) + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, itemsize, item) # <<<<<<<<<<<<<< + * refcount_copying(dst, dtype_is_object, ndim, inc=True) + * +*/ + __pyx_memoryview__slice_assign_scalar(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_itemsize, __pyx_v_item); + + /* "View.MemoryView":1302 + * refcount_copying(dst, dtype_is_object, ndim, inc=False) + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, itemsize, item) + * refcount_copying(dst, dtype_is_object, ndim, inc=True) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1296 + * + * + * @cname('__pyx_memoryview_slice_assign_scalar') # <<<<<<<<<<<<<< + * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, + * size_t itemsize, void *item, +*/ + + /* function exit code */ +} + +/* "View.MemoryView":1305 + * + * + * @cname('__pyx_memoryview__slice_assign_scalar') # <<<<<<<<<<<<<< + * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, + * Py_ssize_t *strides, int ndim, +*/ + +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":1310 + * size_t itemsize, void *item) noexcept nogil: + * cdef Py_ssize_t i + * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t extent = shape[0] + * +*/ + __pyx_v_stride = (__pyx_v_strides[0]); + + /* "View.MemoryView":1311 + * 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":1313 + * 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); + if (__pyx_t_1) { + + /* "View.MemoryView":1314 + * + * 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":1315 + * 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":1316 + * 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":1313 + * cdef Py_ssize_t extent = shape[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * for i in range(extent): + * memcpy(data, item, itemsize) +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":1318 + * data += stride + * else: + * for i in range(extent): # <<<<<<<<<<<<<< + * _slice_assign_scalar(data, shape + 1, strides + 1, ndim - 1, itemsize, item) + * data += stride +*/ + /*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":1319 + * 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":1320 + * for i in range(extent): + * _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":1305 + * + * + * @cname('__pyx_memoryview__slice_assign_scalar') # <<<<<<<<<<<<<< + * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, + * Py_ssize_t *strides, int ndim, +*/ + + /* function exit code */ +} + +/* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x82a3537, 0x6ae9995, 0xb068931, b'name') +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum = {"__pyx_unpickle_Enum", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_type,&__pyx_mstate_global->__pyx_n_u_pyx_checksum,&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 4, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__pyx_unpickle_Enum", 0) < (0)) __PYX_ERR(1, 4, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, i); __PYX_ERR(1, 4, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 4, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 4, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 4, __pyx_L3_error) + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyLong_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 4, __pyx_L3_error) + __pyx_v___pyx_state = ((PyObject*)values[2]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 4, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v___pyx_state), (&PyTuple_Type), 1, "__pyx_state", 1))) __PYX_ERR(1, 4, __pyx_L1_error) + __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 */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __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_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 0); + + /* "(tree fragment)":6 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, tuple __pyx_state): + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x82a3537, 0x6ae9995, 0xb068931, b'name') # <<<<<<<<<<<<<< + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: +*/ + __pyx_t_1 = __Pyx_CheckUnpickleChecksum(__pyx_v___pyx_checksum, 0x82a3537, 0x6ae9995, 0xb068931, __pyx_k_name); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 6, __pyx_L1_error) + + /* "(tree fragment)":7 + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x82a3537, 0x6ae9995, 0xb068931, b'name') + * __pyx_result = Enum.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) +*/ + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_MemviewEnum_type); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v___pyx_type}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_new, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_v___pyx_result = __pyx_t_2; + __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x82a3537, 0x6ae9995, 0xb068931, b'name') + * __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_5 = (__pyx_v___pyx_state != ((PyObject*)Py_None)); + if (__pyx_t_5) { + + /* "(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, __pyx_state: tuple): +*/ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared 'not None'"); + __PYX_ERR(1, 9, __pyx_L1_error) + } + __pyx_t_2 = __pyx_unpickle_Enum__set_state(((struct __pyx_MemviewEnum_obj *)__pyx_v___pyx_result), __pyx_v___pyx_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x82a3537, 0x6ae9995, 0xb068931, b'name') + * __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, __pyx_state: tuple): + * __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)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x82a3537, 0x6ae9995, 0xb068931, b'name') +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __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, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 1) +*/ + +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; + 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, __pyx_state: tuple): + * __pyx_result.name = __pyx_state[0] # <<<<<<<<<<<<<< + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 1) +*/ + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); 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, __pyx_state: tuple): + * __pyx_result.name = __pyx_state[0] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 1) # <<<<<<<<<<<<<< +*/ + __pyx_t_2 = __Pyx_UpdateUnpickledDict(((PyObject *)__pyx_v___pyx_result), __pyx_v___pyx_state, 1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + + /* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 1) +*/ + + /* 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.__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; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":242 + * cdef int type_num + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp itemsize(self) noexcept nogil: + * return PyDataType_ELSIZE(self) +*/ + +static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_8itemsize_itemsize(PyArray_Descr *__pyx_v_self) { + npy_intp __pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":244 + * @property + * cdef inline npy_intp itemsize(self) noexcept nogil: + * return PyDataType_ELSIZE(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyDataType_ELSIZE(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":242 + * cdef int type_num + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp itemsize(self) noexcept nogil: + * return PyDataType_ELSIZE(self) +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":246 + * return PyDataType_ELSIZE(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp alignment(self) noexcept nogil: + * return PyDataType_ALIGNMENT(self) +*/ + +static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_9alignment_alignment(PyArray_Descr *__pyx_v_self) { + npy_intp __pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":248 + * @property + * cdef inline npy_intp alignment(self) noexcept nogil: + * return PyDataType_ALIGNMENT(self) # <<<<<<<<<<<<<< + * + * # Use fields/names with care as they may be NULL. You must check +*/ + __pyx_r = PyDataType_ALIGNMENT(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":246 + * return PyDataType_ELSIZE(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp alignment(self) noexcept nogil: + * return PyDataType_ALIGNMENT(self) +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":252 + * # Use fields/names with care as they may be NULL. You must check + * # for this using PyDataType_HASFIELDS. + * @property # <<<<<<<<<<<<<< + * cdef inline object fields(self): + * return PyDataType_FIELDS(self) +*/ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_5dtype_6fields_fields(PyArray_Descr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1; + __Pyx_RefNannySetupContext("fields", 0); + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":254 + * @property + * cdef inline object fields(self): + * return PyDataType_FIELDS(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyDataType_FIELDS(__pyx_v_self); + __Pyx_INCREF(((PyObject *)__pyx_t_1)); + __pyx_r = ((PyObject *)__pyx_t_1); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":252 + * # Use fields/names with care as they may be NULL. You must check + * # for this using PyDataType_HASFIELDS. + * @property # <<<<<<<<<<<<<< + * cdef inline object fields(self): + * return PyDataType_FIELDS(self) +*/ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":256 + * return PyDataType_FIELDS(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline tuple names(self): + * return PyDataType_NAMES(self) +*/ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_5dtype_5names_names(PyArray_Descr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1; + __Pyx_RefNannySetupContext("names", 0); + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":258 + * @property + * cdef inline tuple names(self): + * return PyDataType_NAMES(self) # <<<<<<<<<<<<<< + * + * # Use PyDataType_HASSUBARRAY to test whether this field is +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyDataType_NAMES(__pyx_v_self); + __Pyx_INCREF(((PyObject*)__pyx_t_1)); + __pyx_r = ((PyObject*)__pyx_t_1); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":256 + * return PyDataType_FIELDS(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline tuple names(self): + * return PyDataType_NAMES(self) +*/ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":263 + * # valid (the pointer can be NULL). Most users should access + * # this field via the inline helper method PyDataType_SHAPE. + * @property # <<<<<<<<<<<<<< + * cdef inline PyArray_ArrayDescr* subarray(self) noexcept nogil: + * return PyDataType_SUBARRAY(self) +*/ + +static CYTHON_INLINE PyArray_ArrayDescr *__pyx_f_5numpy_5dtype_8subarray_subarray(PyArray_Descr *__pyx_v_self) { + PyArray_ArrayDescr *__pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":265 + * @property + * cdef inline PyArray_ArrayDescr* subarray(self) noexcept nogil: + * return PyDataType_SUBARRAY(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyDataType_SUBARRAY(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":263 + * # valid (the pointer can be NULL). Most users should access + * # this field via the inline helper method PyDataType_SHAPE. + * @property # <<<<<<<<<<<<<< + * cdef inline PyArray_ArrayDescr* subarray(self) noexcept nogil: + * return PyDataType_SUBARRAY(self) +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":267 + * return PyDataType_SUBARRAY(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_uint64 flags(self) noexcept nogil: + * """The data types flags.""" +*/ + +static CYTHON_INLINE npy_uint64 __pyx_f_5numpy_5dtype_5flags_flags(PyArray_Descr *__pyx_v_self) { + npy_uint64 __pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":270 + * cdef inline npy_uint64 flags(self) noexcept nogil: + * """The data types flags.""" + * return PyDataType_FLAGS(self) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = PyDataType_FLAGS(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":267 + * return PyDataType_SUBARRAY(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_uint64 flags(self) noexcept nogil: + * """The data types flags.""" +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":279 + * ctypedef class numpy.broadcast [object PyArrayMultiIterObject, check_size ignore]: + * + * @property # <<<<<<<<<<<<<< + * cdef inline int numiter(self) noexcept nogil: + * """The number of arrays that need to be broadcast to the same shape.""" +*/ + +static CYTHON_INLINE int __pyx_f_5numpy_9broadcast_7numiter_numiter(PyArrayMultiIterObject *__pyx_v_self) { + int __pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":282 + * cdef inline int numiter(self) noexcept nogil: + * """The number of arrays that need to be broadcast to the same shape.""" + * return PyArray_MultiIter_NUMITER(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyArray_MultiIter_NUMITER(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":279 + * ctypedef class numpy.broadcast [object PyArrayMultiIterObject, check_size ignore]: + * + * @property # <<<<<<<<<<<<<< + * cdef inline int numiter(self) noexcept nogil: + * """The number of arrays that need to be broadcast to the same shape.""" +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":284 + * return PyArray_MultiIter_NUMITER(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp size(self) noexcept nogil: + * """The total broadcasted size.""" +*/ + +static CYTHON_INLINE npy_intp __pyx_f_5numpy_9broadcast_4size_size(PyArrayMultiIterObject *__pyx_v_self) { + npy_intp __pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":287 + * cdef inline npy_intp size(self) noexcept nogil: + * """The total broadcasted size.""" + * return PyArray_MultiIter_SIZE(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyArray_MultiIter_SIZE(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":284 + * return PyArray_MultiIter_NUMITER(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp size(self) noexcept nogil: + * """The total broadcasted size.""" +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":289 + * return PyArray_MultiIter_SIZE(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp index(self) noexcept nogil: + * """The current (1-d) index into the broadcasted result.""" +*/ + +static CYTHON_INLINE npy_intp __pyx_f_5numpy_9broadcast_5index_index(PyArrayMultiIterObject *__pyx_v_self) { + npy_intp __pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":292 + * cdef inline npy_intp index(self) noexcept nogil: + * """The current (1-d) index into the broadcasted result.""" + * return PyArray_MultiIter_INDEX(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyArray_MultiIter_INDEX(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":289 + * return PyArray_MultiIter_SIZE(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp index(self) noexcept nogil: + * """The current (1-d) index into the broadcasted result.""" +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":294 + * return PyArray_MultiIter_INDEX(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline int nd(self) noexcept nogil: + * """The number of dimensions in the broadcasted result.""" +*/ + +static CYTHON_INLINE int __pyx_f_5numpy_9broadcast_2nd_nd(PyArrayMultiIterObject *__pyx_v_self) { + int __pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":297 + * cdef inline int nd(self) noexcept nogil: + * """The number of dimensions in the broadcasted result.""" + * return PyArray_MultiIter_NDIM(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyArray_MultiIter_NDIM(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":294 + * return PyArray_MultiIter_INDEX(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline int nd(self) noexcept nogil: + * """The number of dimensions in the broadcasted result.""" +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":299 + * return PyArray_MultiIter_NDIM(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp* dimensions(self) noexcept nogil: + * """The shape of the broadcasted result.""" +*/ + +static CYTHON_INLINE npy_intp *__pyx_f_5numpy_9broadcast_10dimensions_dimensions(PyArrayMultiIterObject *__pyx_v_self) { + npy_intp *__pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":302 + * cdef inline npy_intp* dimensions(self) noexcept nogil: + * """The shape of the broadcasted result.""" + * return PyArray_MultiIter_DIMS(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyArray_MultiIter_DIMS(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":299 + * return PyArray_MultiIter_NDIM(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp* dimensions(self) noexcept nogil: + * """The shape of the broadcasted result.""" +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":304 + * return PyArray_MultiIter_DIMS(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline void** iters(self) noexcept nogil: + * """An array of iterator objects that holds the iterators for the arrays to be broadcast together. +*/ + +static CYTHON_INLINE void **__pyx_f_5numpy_9broadcast_5iters_iters(PyArrayMultiIterObject *__pyx_v_self) { + void **__pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":308 + * """An array of iterator objects that holds the iterators for the arrays to be broadcast together. + * On return, the iterators are adjusted for broadcasting.""" + * return PyArray_MultiIter_ITERS(self) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = PyArray_MultiIter_ITERS(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":304 + * return PyArray_MultiIter_DIMS(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline void** iters(self) noexcept nogil: + * """An array of iterator objects that holds the iterators for the arrays to be broadcast together. +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":322 + * # Instead, we use properties that map to the corresponding C-API functions. + * + * @property # <<<<<<<<<<<<<< + * cdef inline PyObject* base(self) noexcept nogil: + * """Returns a borrowed reference to the object owning the data/memory. +*/ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_7ndarray_4base_base(PyArrayObject *__pyx_v_self) { + PyObject *__pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":326 + * """Returns a borrowed reference to the object owning the data/memory. + * """ + * return PyArray_BASE(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyArray_BASE(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":322 + * # Instead, we use properties that map to the corresponding C-API functions. + * + * @property # <<<<<<<<<<<<<< + * cdef inline PyObject* base(self) noexcept nogil: + * """Returns a borrowed reference to the object owning the data/memory. +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":328 + * return PyArray_BASE(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline dtype descr(self): + * """Returns an owned reference to the dtype of the array. +*/ + +static CYTHON_INLINE PyArray_Descr *__pyx_f_5numpy_7ndarray_5descr_descr(PyArrayObject *__pyx_v_self) { + PyArray_Descr *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyArray_Descr *__pyx_t_1; + __Pyx_RefNannySetupContext("descr", 0); + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":332 + * """Returns an owned reference to the dtype of the array. + * """ + * return PyArray_DESCR(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF((PyObject *)__pyx_r); + __pyx_t_1 = PyArray_DESCR(__pyx_v_self); + __Pyx_INCREF((PyObject *)((PyArray_Descr *)__pyx_t_1)); + __pyx_r = ((PyArray_Descr *)__pyx_t_1); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":328 + * return PyArray_BASE(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline dtype descr(self): + * """Returns an owned reference to the dtype of the array. +*/ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":334 + * return PyArray_DESCR(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline int ndim(self) noexcept nogil: + * """Returns the number of dimensions in the array. +*/ + +static CYTHON_INLINE int __pyx_f_5numpy_7ndarray_4ndim_ndim(PyArrayObject *__pyx_v_self) { + int __pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":338 + * """Returns the number of dimensions in the array. + * """ + * return PyArray_NDIM(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyArray_NDIM(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":334 + * return PyArray_DESCR(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline int ndim(self) noexcept nogil: + * """Returns the number of dimensions in the array. +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":340 + * return PyArray_NDIM(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp *shape(self) noexcept nogil: + * """Returns a pointer to the dimensions/shape of the array. +*/ + +static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_5shape_shape(PyArrayObject *__pyx_v_self) { + npy_intp *__pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":346 + * Can return NULL for 0-dimensional arrays. + * """ + * return PyArray_DIMS(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyArray_DIMS(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":340 + * return PyArray_NDIM(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp *shape(self) noexcept nogil: + * """Returns a pointer to the dimensions/shape of the array. +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":348 + * return PyArray_DIMS(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp *strides(self) noexcept nogil: + * """Returns a pointer to the strides of the array. +*/ + +static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_7strides_strides(PyArrayObject *__pyx_v_self) { + npy_intp *__pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":353 + * The number of elements matches the number of dimensions of the array (ndim). + * """ + * return PyArray_STRIDES(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyArray_STRIDES(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":348 + * return PyArray_DIMS(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp *strides(self) noexcept nogil: + * """Returns a pointer to the strides of the array. +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":355 + * return PyArray_STRIDES(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp size(self) noexcept nogil: + * """Returns the total size (in number of elements) of the array. +*/ + +static CYTHON_INLINE npy_intp __pyx_f_5numpy_7ndarray_4size_size(PyArrayObject *__pyx_v_self) { + npy_intp __pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":359 + * """Returns the total size (in number of elements) of the array. + * """ + * return PyArray_SIZE(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyArray_SIZE(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":355 + * return PyArray_STRIDES(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp size(self) noexcept nogil: + * """Returns the total size (in number of elements) of the array. +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":361 + * return PyArray_SIZE(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline char* data(self) noexcept nogil: + * """The pointer to the data buffer as a char*. +*/ + +static CYTHON_INLINE char *__pyx_f_5numpy_7ndarray_4data_data(PyArrayObject *__pyx_v_self) { + char *__pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":368 + * of `PyArray_DATA()` instead, which returns a 'void*'. + * """ + * return PyArray_BYTES(self) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = PyArray_BYTES(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":361 + * return PyArray_SIZE(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline char* data(self) noexcept nogil: + * """The pointer to the data buffer as a char*. +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":776 + * ctypedef long double complex clongdouble_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * +*/ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + 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("PyArray_MultiIterNew1", 0); + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":777 + * + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 777, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":776 + * ctypedef long double complex clongdouble_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":779 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * +*/ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + 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("PyArray_MultiIterNew2", 0); + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":780 + * + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 780, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":779 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":782 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * +*/ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + 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("PyArray_MultiIterNew3", 0); + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":783 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 783, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":782 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":785 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * +*/ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + 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("PyArray_MultiIterNew4", 0); + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":786 + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 786, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":785 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":788 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * +*/ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + 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("PyArray_MultiIterNew5", 0); + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":789 + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + * + * cdef inline tuple PyDataType_SHAPE(dtype d): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 789, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":788 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":791 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape +*/ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2; + __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":792 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: +*/ + __pyx_t_1 = PyDataType_HASSUBARRAY(__pyx_v_d); + if (__pyx_t_1) { + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":793 + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape # <<<<<<<<<<<<<< + * else: + * return () +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_f_5numpy_5dtype_8subarray_subarray(__pyx_v_d)->shape; + __Pyx_INCREF(((PyObject*)__pyx_t_2)); + __pyx_r = ((PyObject*)__pyx_t_2); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":792 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: +*/ + } + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":795 + * return d.subarray.shape + * else: + * return () # <<<<<<<<<<<<<< + * + * +*/ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_mstate_global->__pyx_empty_tuple); + __pyx_r = __pyx_mstate_global->__pyx_empty_tuple; + goto __pyx_L0; + } + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":791 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape +*/ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":994 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base) except *: # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) +*/ + +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":995 + * + * cdef inline void set_array_base(ndarray arr, object base) except *: + * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< + * PyArray_SetBaseObject(arr, base) + * +*/ + Py_INCREF(__pyx_v_base); + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":996 + * cdef inline void set_array_base(ndarray arr, object base) except *: + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< + * + * cdef inline object get_array_base(ndarray arr): +*/ + __pyx_t_1 = PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 996, __pyx_L1_error) + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":994 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base) except *: # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("numpy.set_array_base", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":998 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: +*/ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_v_base; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":999 + * + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< + * if base is NULL: + * return None +*/ + __pyx_v_base = PyArray_BASE(__pyx_v_arr); + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1000 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base +*/ + __pyx_t_1 = (__pyx_v_base == NULL); + if (__pyx_t_1) { + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1001 + * base = PyArray_BASE(arr) + * if base is NULL: + * return None # <<<<<<<<<<<<<< + * return base + * +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1000 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base +*/ + } + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1002 + * if base is NULL: + * return None + * return base # <<<<<<<<<<<<<< + * + * # Versions of the import_* functions which are more suitable for +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_base)); + __pyx_r = ((PyObject *)__pyx_v_base); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":998 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: +*/ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1006 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() +*/ + +static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_array", 0); + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1007 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1008 + * cdef inline int import_array() except -1: + * try: + * __pyx_import_array() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy._core.multiarray failed to import") +*/ + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 1008, __pyx_L3_error) + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1007 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: +*/ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1009 + * try: + * __pyx_import_array() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy._core.multiarray failed to import") + * +*/ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(2, 1009, __pyx_L5_except_error) + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1010 + * __pyx_import_array() + * except Exception: + * raise ImportError("numpy._core.multiarray failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_umath() except -1: +*/ + __pyx_t_9 = NULL; + __pyx_t_10 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_numpy__core_multiarray_failed_to}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ImportError)), __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1010, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + } + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(2, 1010, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1007 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: +*/ + __pyx_L5_except_error:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1006 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1012 + * raise ImportError("numpy._core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() +*/ + +static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_umath", 0); + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1013 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1014 + * cdef inline int import_umath() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy._core.umath failed to import") +*/ + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 1014, __pyx_L3_error) + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1013 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: +*/ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1015 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy._core.umath failed to import") + * +*/ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(2, 1015, __pyx_L5_except_error) + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1016 + * _import_umath() + * except Exception: + * raise ImportError("numpy._core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_ufunc() except -1: +*/ + __pyx_t_9 = NULL; + __pyx_t_10 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_numpy__core_umath_failed_to_impo}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ImportError)), __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1016, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + } + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(2, 1016, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1013 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: +*/ + __pyx_L5_except_error:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1012 + * raise ImportError("numpy._core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1018 + * raise ImportError("numpy._core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() +*/ + +static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_ufunc", 0); + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1019 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1020 + * cdef inline int import_ufunc() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy._core.umath failed to import") +*/ + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 1020, __pyx_L3_error) + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1019 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: +*/ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1021 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy._core.umath failed to import") + * +*/ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(2, 1021, __pyx_L5_except_error) + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1022 + * _import_umath() + * except Exception: + * raise ImportError("numpy._core.umath failed to import") # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_9 = NULL; + __pyx_t_10 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_numpy__core_umath_failed_to_impo}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ImportError)), __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1022, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + } + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(2, 1022, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1019 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: +*/ + __pyx_L5_except_error:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1018 + * raise ImportError("numpy._core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1025 + * + * + * cdef inline bint is_timedelta64_object(object obj) noexcept: # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` +*/ + +static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { + int __pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1037 + * bool + * """ + * return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1025 + * + * + * cdef inline bint is_timedelta64_object(object obj) noexcept: # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1040 + * + * + * cdef inline bint is_datetime64_object(object obj) noexcept: # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` +*/ + +static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { + int __pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1052 + * bool + * """ + * return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1040 + * + * + * cdef inline bint is_datetime64_object(object obj) noexcept: # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1055 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) noexcept nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object +*/ + +static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { + npy_datetime __pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1062 + * also needed. That can be found using `get_datetime64_unit`. + * """ + * return (obj).obval # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1055 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) noexcept nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1065 + * + * + * cdef inline npy_timedelta get_timedelta64_value(object obj) noexcept nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object +*/ + +static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { + npy_timedelta __pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1069 + * returns the int64 value underlying scalar numpy timedelta64 object + * """ + * return (obj).obval # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1065 + * + * + * cdef inline npy_timedelta get_timedelta64_value(object obj) noexcept nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1072 + * + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) noexcept nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. +*/ + +static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { + NPY_DATETIMEUNIT __pyx_r; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1076 + * returns the unit part of the dtype for a numpy datetime64 object. + * """ + * return (obj).obmeta.base # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); + goto __pyx_L0; + + /* "../../../../miniconda3/lib/python3.12/site-packages/numpy/__init__.cython-30.pxd":1072 + * + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) noexcept nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":30 + * cdef public dict _occupied_cache + * + * def __init__(self, int size): # <<<<<<<<<<<<<< + * self.size = size + * self.grid = np.zeros((size, size), dtype=np.int8) +*/ + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_size; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_size,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 30, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 30, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < (0)) __PYX_ERR(0, 30, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, i); __PYX_ERR(0, 30, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 30, __pyx_L3_error) + } + __pyx_v_size = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_size == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 30, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 30, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board___init__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self), __pyx_v_size); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board___init__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, int __pyx_v_size) { + 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; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + __Pyx_memviewslice __pyx_t_8 = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "blokus_gym/core/blokus_cython.pyx":31 + * + * def __init__(self, int size): + * self.size = size # <<<<<<<<<<<<<< + * self.grid = np.zeros((size, size), dtype=np.int8) + * self._occupied_cache = {} +*/ + __pyx_v_self->size = __pyx_v_size; + + /* "blokus_gym/core/blokus_cython.pyx":32 + * def __init__(self, int size): + * self.size = size + * self.grid = np.zeros((size, size), dtype=np.int8) # <<<<<<<<<<<<<< + * self._occupied_cache = {} + * +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_size); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 32, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 32, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_5 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_int8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_2, __pyx_t_6}; + __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_3, __pyx_t_5, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 32, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_dsds_nn___pyx_t_5numpy_int8_t(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_8.memview)) __PYX_ERR(0, 32, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_self->grid, 0); + __pyx_v_self->grid = __pyx_t_8; + __pyx_t_8.memview = NULL; + __pyx_t_8.data = NULL; + + /* "blokus_gym/core/blokus_cython.pyx":33 + * self.size = size + * self.grid = np.zeros((size, size), dtype=np.int8) + * self._occupied_cache = {} # <<<<<<<<<<<<<< + * + * def place(self, int player_idx, list squares): +*/ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_occupied_cache); + __Pyx_DECREF(__pyx_v_self->_occupied_cache); + __pyx_v_self->_occupied_cache = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":30 + * cdef public dict _occupied_cache + * + * def __init__(self, int size): # <<<<<<<<<<<<<< + * self.size = size + * self.grid = np.zeros((size, size), dtype=np.int8) +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_8, 1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":35 + * self._occupied_cache = {} + * + * def place(self, int player_idx, list squares): # <<<<<<<<<<<<<< + * """Place a player's piece on the board.""" + * cdef int x, y +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_3place(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_2place, "Place a player's piece on the board."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_3place = {"place", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_3place, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_2place}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_3place(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + int __pyx_v_player_idx; + PyObject *__pyx_v_squares = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("place (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_player_idx,&__pyx_mstate_global->__pyx_n_u_squares,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 35, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 35, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 35, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "place", 0) < (0)) __PYX_ERR(0, 35, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("place", 1, 2, 2, i); __PYX_ERR(0, 35, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 35, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 35, __pyx_L3_error) + } + __pyx_v_player_idx = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_player_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 35, __pyx_L3_error) + __pyx_v_squares = ((PyObject*)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("place", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 35, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.place", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_squares), (&PyList_Type), 1, "squares", 1))) __PYX_ERR(0, 35, __pyx_L1_error) + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_2place(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self), __pyx_v_player_idx, __pyx_v_squares); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_2place(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, int __pyx_v_player_idx, PyObject *__pyx_v_squares) { + int __pyx_v_x; + int __pyx_v_y; + __Pyx_memviewslice __pyx_v_grid_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_v_size; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1 = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *(*__pyx_t_9)(PyObject *); + int __pyx_t_10; + int __pyx_t_11; + int __pyx_t_12; + Py_ssize_t __pyx_t_13; + Py_ssize_t __pyx_t_14; + size_t __pyx_t_15; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("place", 0); + + /* "blokus_gym/core/blokus_cython.pyx":38 + * """Place a player's piece on the board.""" + * cdef int x, y + * cdef cnp.int8_t[:, :] grid_view = self.grid # <<<<<<<<<<<<<< + * cdef int size = self.size + * +*/ + if (unlikely(!__pyx_v_self->grid.memview)) {PyErr_SetString(PyExc_AttributeError,"Memoryview is not initialized");__PYX_ERR(0, 38, __pyx_L1_error)} + __pyx_t_1 = __pyx_v_self->grid; + __PYX_INC_MEMVIEW(&__pyx_t_1, 1); + __pyx_v_grid_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "blokus_gym/core/blokus_cython.pyx":39 + * cdef int x, y + * cdef cnp.int8_t[:, :] grid_view = self.grid + * cdef int size = self.size # <<<<<<<<<<<<<< + * + * for x, y in squares: +*/ + __pyx_t_2 = __pyx_v_self->size; + __pyx_v_size = __pyx_t_2; + + /* "blokus_gym/core/blokus_cython.pyx":41 + * cdef int size = self.size + * + * for x, y in squares: # <<<<<<<<<<<<<< + * if 0 <= x < size and 0 <= y < size: + * grid_view[y, x] = player_idx +*/ + if (unlikely(__pyx_v_squares == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 41, __pyx_L1_error) + } + __pyx_t_3 = __pyx_v_squares; __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 41, __pyx_L1_error) + #endif + if (__pyx_t_4 >= __pyx_temp) break; + } + __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_3, __pyx_t_4, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_4; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) { + PyObject* sequence = __pyx_t_5; + 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(0, 41, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_6); + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_7); + } else { + __pyx_t_6 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_7); + } + #else + __pyx_t_6 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_8 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_8); + index = 0; __pyx_t_6 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + index = 1; __pyx_t_7 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_7)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_8), 2) < (0)) __PYX_ERR(0, 41, __pyx_L1_error) + __pyx_t_9 = NULL; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L6_unpacking_done; + __pyx_L5_unpacking_failed:; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_9 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 41, __pyx_L1_error) + __pyx_L6_unpacking_done:; + } + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_6); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_10 = __Pyx_PyLong_As_int(__pyx_t_7); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 41, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_x = __pyx_t_2; + __pyx_v_y = __pyx_t_10; + + /* "blokus_gym/core/blokus_cython.pyx":42 + * + * for x, y in squares: + * if 0 <= x < size and 0 <= y < size: # <<<<<<<<<<<<<< + * grid_view[y, x] = player_idx + * +*/ + __pyx_t_12 = (0 <= __pyx_v_x); + if (__pyx_t_12) { + __pyx_t_12 = (__pyx_v_x < __pyx_v_size); + } + if (__pyx_t_12) { + } else { + __pyx_t_11 = __pyx_t_12; + goto __pyx_L8_bool_binop_done; + } + __pyx_t_12 = (0 <= __pyx_v_y); + if (__pyx_t_12) { + __pyx_t_12 = (__pyx_v_y < __pyx_v_size); + } + __pyx_t_11 = __pyx_t_12; + __pyx_L8_bool_binop_done:; + if (__pyx_t_11) { + + /* "blokus_gym/core/blokus_cython.pyx":43 + * for x, y in squares: + * if 0 <= x < size and 0 <= y < size: + * grid_view[y, x] = player_idx # <<<<<<<<<<<<<< + * + * # Update occupied cache incrementally +*/ + __pyx_t_13 = __pyx_v_y; + __pyx_t_14 = __pyx_v_x; + __pyx_t_10 = -1; + if (__pyx_t_13 < 0) { + __pyx_t_13 += __pyx_v_grid_view.shape[0]; + if (unlikely(__pyx_t_13 < 0)) __pyx_t_10 = 0; + } else if (unlikely(__pyx_t_13 >= __pyx_v_grid_view.shape[0])) __pyx_t_10 = 0; + if (__pyx_t_14 < 0) { + __pyx_t_14 += __pyx_v_grid_view.shape[1]; + if (unlikely(__pyx_t_14 < 0)) __pyx_t_10 = 1; + } else if (unlikely(__pyx_t_14 >= __pyx_v_grid_view.shape[1])) __pyx_t_10 = 1; + if (unlikely(__pyx_t_10 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_10); + __PYX_ERR(0, 43, __pyx_L1_error) + } + *((__pyx_t_5numpy_int8_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_grid_view.data + __pyx_t_13 * __pyx_v_grid_view.strides[0]) ) + __pyx_t_14 * __pyx_v_grid_view.strides[1]) )) = __pyx_v_player_idx; + + /* "blokus_gym/core/blokus_cython.pyx":42 + * + * for x, y in squares: + * if 0 <= x < size and 0 <= y < size: # <<<<<<<<<<<<<< + * grid_view[y, x] = player_idx + * +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":41 + * cdef int size = self.size + * + * for x, y in squares: # <<<<<<<<<<<<<< + * if 0 <= x < size and 0 <= y < size: + * grid_view[y, x] = player_idx +*/ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":46 + * + * # Update occupied cache incrementally + * if player_idx in self._occupied_cache: # <<<<<<<<<<<<<< + * self._occupied_cache[player_idx].update(squares) + * +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_player_idx); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(__pyx_v_self->_occupied_cache == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 46, __pyx_L1_error) + } + __pyx_t_11 = (__Pyx_PyDict_ContainsTF(__pyx_t_3, __pyx_v_self->_occupied_cache, Py_EQ)); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 46, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_11) { + + /* "blokus_gym/core/blokus_cython.pyx":47 + * # Update occupied cache incrementally + * if player_idx in self._occupied_cache: + * self._occupied_cache[player_idx].update(squares) # <<<<<<<<<<<<<< + * + * def clear(self) -> None: +*/ + if (unlikely(__pyx_v_self->_occupied_cache == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 47, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_player_idx); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyDict_GetItem(__pyx_v_self->_occupied_cache, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_5 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_15 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_squares}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_update, __pyx_callargs+__pyx_t_15, (2-__pyx_t_15) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 47, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":46 + * + * # Update occupied cache incrementally + * if player_idx in self._occupied_cache: # <<<<<<<<<<<<<< + * self._occupied_cache[player_idx].update(squares) + * +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":35 + * self._occupied_cache = {} + * + * def place(self, int player_idx, list squares): # <<<<<<<<<<<<<< + * """Place a player's piece on the board.""" + * cdef int x, y +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __PYX_XCLEAR_MEMVIEW(&__pyx_t_1, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.place", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_grid_view, 1); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":49 + * self._occupied_cache[player_idx].update(squares) + * + * def clear(self) -> None: # <<<<<<<<<<<<<< + * """Reset the board to empty.""" + * self.grid.fill(0) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_5clear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_4clear, "Reset the board to empty."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_5clear = {"clear", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_5clear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_4clear}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_5clear(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("clear (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("clear", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("clear", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_4clear(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_4clear(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("clear", 0); + + /* "blokus_gym/core/blokus_cython.pyx":51 + * def clear(self) -> None: + * """Reset the board to empty.""" + * self.grid.fill(0) # <<<<<<<<<<<<<< + * + * def is_empty(self, int x, int y) -> bool: +*/ + if (unlikely(!__pyx_v_self->grid.memview)) {PyErr_SetString(PyExc_AttributeError,"Memoryview is not initialized");__PYX_ERR(0, 51, __pyx_L1_error)} + __pyx_t_3 = __pyx_memoryview_fromslice(__pyx_v_self->grid, 2, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int8_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int8_t, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_int_0}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_fill, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 51, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":49 + * self._occupied_cache[player_idx].update(squares) + * + * def clear(self) -> None: # <<<<<<<<<<<<<< + * """Reset the board to empty.""" + * self.grid.fill(0) +*/ + + /* 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_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.clear", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":53 + * self.grid.fill(0) + * + * def is_empty(self, int x, int y) -> bool: # <<<<<<<<<<<<<< + * """Check if a cell is empty (C-level fast).""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_7is_empty(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_6is_empty, "Check if a cell is empty (C-level fast)."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_7is_empty = {"is_empty", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_7is_empty, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_6is_empty}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_7is_empty(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + int __pyx_v_x; + int __pyx_v_y; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_empty (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_x,&__pyx_mstate_global->__pyx_n_u_y,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 53, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 53, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 53, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "is_empty", 0) < (0)) __PYX_ERR(0, 53, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("is_empty", 1, 2, 2, i); __PYX_ERR(0, 53, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 53, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 53, __pyx_L3_error) + } + __pyx_v_x = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_x == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 53, __pyx_L3_error) + __pyx_v_y = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_y == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 53, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("is_empty", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 53, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.is_empty", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_6is_empty(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self), __pyx_v_x, __pyx_v_y); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_6is_empty(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, int __pyx_v_x, int __pyx_v_y) { + __Pyx_memviewslice __pyx_v_grid_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_v_size; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1 = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + Py_ssize_t __pyx_t_5; + Py_ssize_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_empty", 0); + + /* "blokus_gym/core/blokus_cython.pyx":55 + * def is_empty(self, int x, int y) -> bool: + * """Check if a cell is empty (C-level fast).""" + * cdef cnp.int8_t[:, :] grid_view = self.grid # <<<<<<<<<<<<<< + * cdef int size = self.size + * +*/ + if (unlikely(!__pyx_v_self->grid.memview)) {PyErr_SetString(PyExc_AttributeError,"Memoryview is not initialized");__PYX_ERR(0, 55, __pyx_L1_error)} + __pyx_t_1 = __pyx_v_self->grid; + __PYX_INC_MEMVIEW(&__pyx_t_1, 1); + __pyx_v_grid_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "blokus_gym/core/blokus_cython.pyx":56 + * """Check if a cell is empty (C-level fast).""" + * cdef cnp.int8_t[:, :] grid_view = self.grid + * cdef int size = self.size # <<<<<<<<<<<<<< + * + * if 0 <= x < size and 0 <= y < size: +*/ + __pyx_t_2 = __pyx_v_self->size; + __pyx_v_size = __pyx_t_2; + + /* "blokus_gym/core/blokus_cython.pyx":58 + * cdef int size = self.size + * + * if 0 <= x < size and 0 <= y < size: # <<<<<<<<<<<<<< + * return grid_view[y, x] == 0 + * return False +*/ + __pyx_t_4 = (0 <= __pyx_v_x); + if (__pyx_t_4) { + __pyx_t_4 = (__pyx_v_x < __pyx_v_size); + } + if (__pyx_t_4) { + } else { + __pyx_t_3 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (0 <= __pyx_v_y); + if (__pyx_t_4) { + __pyx_t_4 = (__pyx_v_y < __pyx_v_size); + } + __pyx_t_3 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_3) { + + /* "blokus_gym/core/blokus_cython.pyx":59 + * + * if 0 <= x < size and 0 <= y < size: + * return grid_view[y, x] == 0 # <<<<<<<<<<<<<< + * return False + * +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = __pyx_v_y; + __pyx_t_6 = __pyx_v_x; + __pyx_t_2 = -1; + if (__pyx_t_5 < 0) { + __pyx_t_5 += __pyx_v_grid_view.shape[0]; + if (unlikely(__pyx_t_5 < 0)) __pyx_t_2 = 0; + } else if (unlikely(__pyx_t_5 >= __pyx_v_grid_view.shape[0])) __pyx_t_2 = 0; + if (__pyx_t_6 < 0) { + __pyx_t_6 += __pyx_v_grid_view.shape[1]; + if (unlikely(__pyx_t_6 < 0)) __pyx_t_2 = 1; + } else if (unlikely(__pyx_t_6 >= __pyx_v_grid_view.shape[1])) __pyx_t_2 = 1; + if (unlikely(__pyx_t_2 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_2); + __PYX_ERR(0, 59, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_PyBool_FromLong(((*((__pyx_t_5numpy_int8_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_grid_view.data + __pyx_t_5 * __pyx_v_grid_view.strides[0]) ) + __pyx_t_6 * __pyx_v_grid_view.strides[1]) ))) == 0)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 59, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_r = __pyx_t_7; + __pyx_t_7 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":58 + * cdef int size = self.size + * + * if 0 <= x < size and 0 <= y < size: # <<<<<<<<<<<<<< + * return grid_view[y, x] == 0 + * return False +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":60 + * if 0 <= x < size and 0 <= y < size: + * return grid_view[y, x] == 0 + * return False # <<<<<<<<<<<<<< + * + * def in_bounds(self, int x, int y) -> bool: +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":53 + * self.grid.fill(0) + * + * def is_empty(self, int x, int y) -> bool: # <<<<<<<<<<<<<< + * """Check if a cell is empty (C-level fast).""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + + /* function exit code */ + __pyx_L1_error:; + __PYX_XCLEAR_MEMVIEW(&__pyx_t_1, 1); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.is_empty", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_grid_view, 1); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":62 + * return False + * + * def in_bounds(self, int x, int y) -> bool: # <<<<<<<<<<<<<< + * """Check if coordinates are within the board (C-level fast).""" + * cdef int size = self.size +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_9in_bounds(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_8in_bounds, "Check if coordinates are within the board (C-level fast)."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_9in_bounds = {"in_bounds", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_9in_bounds, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_8in_bounds}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_9in_bounds(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + int __pyx_v_x; + int __pyx_v_y; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("in_bounds (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_x,&__pyx_mstate_global->__pyx_n_u_y,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 62, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 62, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 62, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "in_bounds", 0) < (0)) __PYX_ERR(0, 62, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("in_bounds", 1, 2, 2, i); __PYX_ERR(0, 62, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 62, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 62, __pyx_L3_error) + } + __pyx_v_x = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_x == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 62, __pyx_L3_error) + __pyx_v_y = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_y == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 62, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("in_bounds", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 62, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.in_bounds", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_8in_bounds(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self), __pyx_v_x, __pyx_v_y); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_8in_bounds(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, int __pyx_v_x, int __pyx_v_y) { + int __pyx_v_size; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("in_bounds", 0); + + /* "blokus_gym/core/blokus_cython.pyx":64 + * def in_bounds(self, int x, int y) -> bool: + * """Check if coordinates are within the board (C-level fast).""" + * cdef int size = self.size # <<<<<<<<<<<<<< + * return 0 <= x < size and 0 <= y < size + * +*/ + __pyx_t_1 = __pyx_v_self->size; + __pyx_v_size = __pyx_t_1; + + /* "blokus_gym/core/blokus_cython.pyx":65 + * """Check if coordinates are within the board (C-level fast).""" + * cdef int size = self.size + * return 0 <= x < size and 0 <= y < size # <<<<<<<<<<<<<< + * + * def has_overlap(self, list squares) -> bool: +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = (0 <= __pyx_v_x); + if (__pyx_t_3) { + __pyx_t_3 = (__pyx_v_x < __pyx_v_size); + } + if (__pyx_t_3) { + } else { + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L3_bool_binop_done; + } + __pyx_t_3 = (0 <= __pyx_v_y); + if (__pyx_t_3) { + __pyx_t_3 = (__pyx_v_y < __pyx_v_size); + } + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_t_3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 65, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __pyx_t_4; + __pyx_t_4 = 0; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":62 + * return False + * + * def in_bounds(self, int x, int y) -> bool: # <<<<<<<<<<<<<< + * """Check if coordinates are within the board (C-level fast).""" + * cdef int size = self.size +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.in_bounds", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":67 + * return 0 <= x < size and 0 <= y < size + * + * def has_overlap(self, list squares) -> bool: # <<<<<<<<<<<<<< + * """Check if any square is already occupied (C-level fast).""" + * cdef int x, y +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_11has_overlap(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_10has_overlap, "Check if any square is already occupied (C-level fast)."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_11has_overlap = {"has_overlap", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_11has_overlap, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_10has_overlap}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_11has_overlap(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_squares = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("has_overlap (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_squares,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 67, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 67, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "has_overlap", 0) < (0)) __PYX_ERR(0, 67, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("has_overlap", 1, 1, 1, i); __PYX_ERR(0, 67, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 67, __pyx_L3_error) + } + __pyx_v_squares = ((PyObject*)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("has_overlap", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 67, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.has_overlap", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_squares), (&PyList_Type), 1, "squares", 1))) __PYX_ERR(0, 67, __pyx_L1_error) + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_10has_overlap(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self), __pyx_v_squares); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_10has_overlap(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, PyObject *__pyx_v_squares) { + int __pyx_v_x; + int __pyx_v_y; + __Pyx_memviewslice __pyx_v_grid_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_v_size; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1 = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *(*__pyx_t_9)(PyObject *); + int __pyx_t_10; + int __pyx_t_11; + int __pyx_t_12; + int __pyx_t_13; + Py_ssize_t __pyx_t_14; + Py_ssize_t __pyx_t_15; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("has_overlap", 0); + + /* "blokus_gym/core/blokus_cython.pyx":70 + * """Check if any square is already occupied (C-level fast).""" + * cdef int x, y + * cdef cnp.int8_t[:, :] grid_view = self.grid # <<<<<<<<<<<<<< + * cdef int size = self.size + * +*/ + if (unlikely(!__pyx_v_self->grid.memview)) {PyErr_SetString(PyExc_AttributeError,"Memoryview is not initialized");__PYX_ERR(0, 70, __pyx_L1_error)} + __pyx_t_1 = __pyx_v_self->grid; + __PYX_INC_MEMVIEW(&__pyx_t_1, 1); + __pyx_v_grid_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "blokus_gym/core/blokus_cython.pyx":71 + * cdef int x, y + * cdef cnp.int8_t[:, :] grid_view = self.grid + * cdef int size = self.size # <<<<<<<<<<<<<< + * + * for x, y in squares: +*/ + __pyx_t_2 = __pyx_v_self->size; + __pyx_v_size = __pyx_t_2; + + /* "blokus_gym/core/blokus_cython.pyx":73 + * cdef int size = self.size + * + * for x, y in squares: # <<<<<<<<<<<<<< + * if not (0 <= x < size and 0 <= y < size) or grid_view[y, x] != 0: + * return True +*/ + if (unlikely(__pyx_v_squares == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 73, __pyx_L1_error) + } + __pyx_t_3 = __pyx_v_squares; __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 73, __pyx_L1_error) + #endif + if (__pyx_t_4 >= __pyx_temp) break; + } + __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_3, __pyx_t_4, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_4; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) { + PyObject* sequence = __pyx_t_5; + 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(0, 73, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_6); + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_7); + } else { + __pyx_t_6 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_7); + } + #else + __pyx_t_6 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + #endif + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_8 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_8); + index = 0; __pyx_t_6 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + index = 1; __pyx_t_7 = __pyx_t_9(__pyx_t_8); if (unlikely(!__pyx_t_7)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_8), 2) < (0)) __PYX_ERR(0, 73, __pyx_L1_error) + __pyx_t_9 = NULL; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L6_unpacking_done; + __pyx_L5_unpacking_failed:; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_9 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 73, __pyx_L1_error) + __pyx_L6_unpacking_done:; + } + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_6); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_10 = __Pyx_PyLong_As_int(__pyx_t_7); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 73, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_v_x = __pyx_t_2; + __pyx_v_y = __pyx_t_10; + + /* "blokus_gym/core/blokus_cython.pyx":74 + * + * for x, y in squares: + * if not (0 <= x < size and 0 <= y < size) or grid_view[y, x] != 0: # <<<<<<<<<<<<<< + * return True + * return False +*/ + __pyx_t_13 = (0 <= __pyx_v_x); + if (__pyx_t_13) { + __pyx_t_13 = (__pyx_v_x < __pyx_v_size); + } + if (__pyx_t_13) { + } else { + __pyx_t_12 = __pyx_t_13; + goto __pyx_L10_bool_binop_done; + } + __pyx_t_13 = (0 <= __pyx_v_y); + if (__pyx_t_13) { + __pyx_t_13 = (__pyx_v_y < __pyx_v_size); + } + __pyx_t_12 = __pyx_t_13; + __pyx_L10_bool_binop_done:; + __pyx_t_13 = (!__pyx_t_12); + if (!__pyx_t_13) { + } else { + __pyx_t_11 = __pyx_t_13; + goto __pyx_L8_bool_binop_done; + } + __pyx_t_14 = __pyx_v_y; + __pyx_t_15 = __pyx_v_x; + __pyx_t_10 = -1; + if (__pyx_t_14 < 0) { + __pyx_t_14 += __pyx_v_grid_view.shape[0]; + if (unlikely(__pyx_t_14 < 0)) __pyx_t_10 = 0; + } else if (unlikely(__pyx_t_14 >= __pyx_v_grid_view.shape[0])) __pyx_t_10 = 0; + if (__pyx_t_15 < 0) { + __pyx_t_15 += __pyx_v_grid_view.shape[1]; + if (unlikely(__pyx_t_15 < 0)) __pyx_t_10 = 1; + } else if (unlikely(__pyx_t_15 >= __pyx_v_grid_view.shape[1])) __pyx_t_10 = 1; + if (unlikely(__pyx_t_10 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_10); + __PYX_ERR(0, 74, __pyx_L1_error) + } + __pyx_t_13 = ((*((__pyx_t_5numpy_int8_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_grid_view.data + __pyx_t_14 * __pyx_v_grid_view.strides[0]) ) + __pyx_t_15 * __pyx_v_grid_view.strides[1]) ))) != 0); + __pyx_t_11 = __pyx_t_13; + __pyx_L8_bool_binop_done:; + if (__pyx_t_11) { + + /* "blokus_gym/core/blokus_cython.pyx":75 + * for x, y in squares: + * if not (0 <= x < size and 0 <= y < size) or grid_view[y, x] != 0: + * return True # <<<<<<<<<<<<<< + * return False + * +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":74 + * + * for x, y in squares: + * if not (0 <= x < size and 0 <= y < size) or grid_view[y, x] != 0: # <<<<<<<<<<<<<< + * return True + * return False +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":73 + * cdef int size = self.size + * + * for x, y in squares: # <<<<<<<<<<<<<< + * if not (0 <= x < size and 0 <= y < size) or grid_view[y, x] != 0: + * return True +*/ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":76 + * if not (0 <= x < size and 0 <= y < size) or grid_view[y, x] != 0: + * return True + * return False # <<<<<<<<<<<<<< + * + * cdef bint is_cell_empty(self, int x, int y): +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":67 + * return 0 <= x < size and 0 <= y < size + * + * def has_overlap(self, list squares) -> bool: # <<<<<<<<<<<<<< + * """Check if any square is already occupied (C-level fast).""" + * cdef int x, y +*/ + + /* function exit code */ + __pyx_L1_error:; + __PYX_XCLEAR_MEMVIEW(&__pyx_t_1, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.has_overlap", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_grid_view, 1); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":78 + * return False + * + * cdef bint is_cell_empty(self, int x, int y): # <<<<<<<<<<<<<< + * """Check if a cell is empty (C-level fast, inlineable).""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + +static int __pyx_f_10blokus_gym_4core_13blokus_cython_5Board_is_cell_empty(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, int __pyx_v_x, int __pyx_v_y) { + __Pyx_memviewslice __pyx_v_grid_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_v_size; + int __pyx_r; + __Pyx_memviewslice __pyx_t_1 = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_t_2; + int __pyx_t_3; + int __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; + + /* "blokus_gym/core/blokus_cython.pyx":80 + * cdef bint is_cell_empty(self, int x, int y): + * """Check if a cell is empty (C-level fast, inlineable).""" + * cdef cnp.int8_t[:, :] grid_view = self.grid # <<<<<<<<<<<<<< + * cdef int size = self.size + * +*/ + if (unlikely(!__pyx_v_self->grid.memview)) {PyErr_SetString(PyExc_AttributeError,"Memoryview is not initialized");__PYX_ERR(0, 80, __pyx_L1_error)} + __pyx_t_1 = __pyx_v_self->grid; + __PYX_INC_MEMVIEW(&__pyx_t_1, 1); + __pyx_v_grid_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "blokus_gym/core/blokus_cython.pyx":81 + * """Check if a cell is empty (C-level fast, inlineable).""" + * cdef cnp.int8_t[:, :] grid_view = self.grid + * cdef int size = self.size # <<<<<<<<<<<<<< + * + * return 0 <= x < size and 0 <= y < size and grid_view[y, x] == 0 +*/ + __pyx_t_2 = __pyx_v_self->size; + __pyx_v_size = __pyx_t_2; + + /* "blokus_gym/core/blokus_cython.pyx":83 + * cdef int size = self.size + * + * return 0 <= x < size and 0 <= y < size and grid_view[y, x] == 0 # <<<<<<<<<<<<<< + * + * def get_cell(self, int x, int y) -> int: +*/ + __pyx_t_4 = (0 <= __pyx_v_x); + if (__pyx_t_4) { + __pyx_t_4 = (__pyx_v_x < __pyx_v_size); + } + if (__pyx_t_4) { + } else { + __pyx_t_3 = __pyx_t_4; + goto __pyx_L3_bool_binop_done; + } + __pyx_t_4 = (0 <= __pyx_v_y); + if (__pyx_t_4) { + __pyx_t_4 = (__pyx_v_y < __pyx_v_size); + } + if (__pyx_t_4) { + } else { + __pyx_t_3 = __pyx_t_4; + goto __pyx_L3_bool_binop_done; + } + __pyx_t_5 = __pyx_v_y; + __pyx_t_6 = __pyx_v_x; + __pyx_t_2 = -1; + if (__pyx_t_5 < 0) { + __pyx_t_5 += __pyx_v_grid_view.shape[0]; + if (unlikely(__pyx_t_5 < 0)) __pyx_t_2 = 0; + } else if (unlikely(__pyx_t_5 >= __pyx_v_grid_view.shape[0])) __pyx_t_2 = 0; + if (__pyx_t_6 < 0) { + __pyx_t_6 += __pyx_v_grid_view.shape[1]; + if (unlikely(__pyx_t_6 < 0)) __pyx_t_2 = 1; + } else if (unlikely(__pyx_t_6 >= __pyx_v_grid_view.shape[1])) __pyx_t_2 = 1; + if (unlikely(__pyx_t_2 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_2); + __PYX_ERR(0, 83, __pyx_L1_error) + } + __pyx_t_4 = ((*((__pyx_t_5numpy_int8_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_grid_view.data + __pyx_t_5 * __pyx_v_grid_view.strides[0]) ) + __pyx_t_6 * __pyx_v_grid_view.strides[1]) ))) == 0); + __pyx_t_3 = __pyx_t_4; + __pyx_L3_bool_binop_done:; + __pyx_r = __pyx_t_3; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":78 + * return False + * + * cdef bint is_cell_empty(self, int x, int y): # <<<<<<<<<<<<<< + * """Check if a cell is empty (C-level fast, inlineable).""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + + /* function exit code */ + __pyx_L1_error:; + __PYX_XCLEAR_MEMVIEW(&__pyx_t_1, 1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.is_cell_empty", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_grid_view, 1); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":85 + * return 0 <= x < size and 0 <= y < size and grid_view[y, x] == 0 + * + * def get_cell(self, int x, int y) -> int: # <<<<<<<<<<<<<< + * """Get the player index at a cell (0 = empty).""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_13get_cell(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_12get_cell, "Get the player index at a cell (0 = empty)."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_13get_cell = {"get_cell", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_13get_cell, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_12get_cell}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_13get_cell(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + int __pyx_v_x; + int __pyx_v_y; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_cell (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_x,&__pyx_mstate_global->__pyx_n_u_y,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 85, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 85, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 85, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_cell", 0) < (0)) __PYX_ERR(0, 85, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_cell", 1, 2, 2, i); __PYX_ERR(0, 85, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 85, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 85, __pyx_L3_error) + } + __pyx_v_x = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_x == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L3_error) + __pyx_v_y = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_y == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 85, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_cell", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 85, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.get_cell", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_12get_cell(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self), __pyx_v_x, __pyx_v_y); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_12get_cell(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, int __pyx_v_x, int __pyx_v_y) { + __Pyx_memviewslice __pyx_v_grid_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_v_size; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1 = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + Py_ssize_t __pyx_t_5; + Py_ssize_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_cell", 0); + + /* "blokus_gym/core/blokus_cython.pyx":87 + * def get_cell(self, int x, int y) -> int: + * """Get the player index at a cell (0 = empty).""" + * cdef cnp.int8_t[:, :] grid_view = self.grid # <<<<<<<<<<<<<< + * cdef int size = self.size + * +*/ + if (unlikely(!__pyx_v_self->grid.memview)) {PyErr_SetString(PyExc_AttributeError,"Memoryview is not initialized");__PYX_ERR(0, 87, __pyx_L1_error)} + __pyx_t_1 = __pyx_v_self->grid; + __PYX_INC_MEMVIEW(&__pyx_t_1, 1); + __pyx_v_grid_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "blokus_gym/core/blokus_cython.pyx":88 + * """Get the player index at a cell (0 = empty).""" + * cdef cnp.int8_t[:, :] grid_view = self.grid + * cdef int size = self.size # <<<<<<<<<<<<<< + * + * if 0 <= x < size and 0 <= y < size: +*/ + __pyx_t_2 = __pyx_v_self->size; + __pyx_v_size = __pyx_t_2; + + /* "blokus_gym/core/blokus_cython.pyx":90 + * cdef int size = self.size + * + * if 0 <= x < size and 0 <= y < size: # <<<<<<<<<<<<<< + * return grid_view[y, x] + * return 0 +*/ + __pyx_t_4 = (0 <= __pyx_v_x); + if (__pyx_t_4) { + __pyx_t_4 = (__pyx_v_x < __pyx_v_size); + } + if (__pyx_t_4) { + } else { + __pyx_t_3 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = (0 <= __pyx_v_y); + if (__pyx_t_4) { + __pyx_t_4 = (__pyx_v_y < __pyx_v_size); + } + __pyx_t_3 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_3) { + + /* "blokus_gym/core/blokus_cython.pyx":91 + * + * if 0 <= x < size and 0 <= y < size: + * return grid_view[y, x] # <<<<<<<<<<<<<< + * return 0 + * +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = __pyx_v_y; + __pyx_t_6 = __pyx_v_x; + __pyx_t_2 = -1; + if (__pyx_t_5 < 0) { + __pyx_t_5 += __pyx_v_grid_view.shape[0]; + if (unlikely(__pyx_t_5 < 0)) __pyx_t_2 = 0; + } else if (unlikely(__pyx_t_5 >= __pyx_v_grid_view.shape[0])) __pyx_t_2 = 0; + if (__pyx_t_6 < 0) { + __pyx_t_6 += __pyx_v_grid_view.shape[1]; + if (unlikely(__pyx_t_6 < 0)) __pyx_t_2 = 1; + } else if (unlikely(__pyx_t_6 >= __pyx_v_grid_view.shape[1])) __pyx_t_2 = 1; + if (unlikely(__pyx_t_2 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_2); + __PYX_ERR(0, 91, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_PyLong_From_npy_int8((*((__pyx_t_5numpy_int8_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_grid_view.data + __pyx_t_5 * __pyx_v_grid_view.strides[0]) ) + __pyx_t_6 * __pyx_v_grid_view.strides[1]) )))); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 91, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_PyInt_FromNumber(&__pyx_t_7, NULL, 0) < (0)) __PYX_ERR(0, 91, __pyx_L1_error) + __pyx_r = ((PyObject*)__pyx_t_7); + __pyx_t_7 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":90 + * cdef int size = self.size + * + * if 0 <= x < size and 0 <= y < size: # <<<<<<<<<<<<<< + * return grid_view[y, x] + * return 0 +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":92 + * if 0 <= x < size and 0 <= y < size: + * return grid_view[y, x] + * return 0 # <<<<<<<<<<<<<< + * + * def get_player_squares(self, int player_idx) -> list: +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __pyx_r = __pyx_mstate_global->__pyx_int_0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":85 + * return 0 <= x < size and 0 <= y < size and grid_view[y, x] == 0 + * + * def get_cell(self, int x, int y) -> int: # <<<<<<<<<<<<<< + * """Get the player index at a cell (0 = empty).""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + + /* function exit code */ + __pyx_L1_error:; + __PYX_XCLEAR_MEMVIEW(&__pyx_t_1, 1); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.get_cell", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_grid_view, 1); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":94 + * return 0 + * + * def get_player_squares(self, int player_idx) -> list: # <<<<<<<<<<<<<< + * """Get all squares occupied by a player.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_15get_player_squares(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_14get_player_squares, "Get all squares occupied by a player."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_15get_player_squares = {"get_player_squares", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_15get_player_squares, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_14get_player_squares}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_15get_player_squares(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + int __pyx_v_player_idx; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_player_squares (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_player_idx,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 94, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 94, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_player_squares", 0) < (0)) __PYX_ERR(0, 94, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_player_squares", 1, 1, 1, i); __PYX_ERR(0, 94, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 94, __pyx_L3_error) + } + __pyx_v_player_idx = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_player_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 94, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_player_squares", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 94, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.get_player_squares", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_14get_player_squares(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self), __pyx_v_player_idx); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_14get_player_squares(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, int __pyx_v_player_idx) { + __Pyx_memviewslice __pyx_v_grid_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_v_size; + PyObject *__pyx_v_result = 0; + int __pyx_v_x; + int __pyx_v_y; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1 = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + Py_ssize_t __pyx_t_9; + Py_ssize_t __pyx_t_10; + int __pyx_t_11; + int __pyx_t_12; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + int __pyx_t_15; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_player_squares", 0); + + /* "blokus_gym/core/blokus_cython.pyx":96 + * def get_player_squares(self, int player_idx) -> list: + * """Get all squares occupied by a player.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid # <<<<<<<<<<<<<< + * cdef int size = self.size + * cdef list result = [] +*/ + if (unlikely(!__pyx_v_self->grid.memview)) {PyErr_SetString(PyExc_AttributeError,"Memoryview is not initialized");__PYX_ERR(0, 96, __pyx_L1_error)} + __pyx_t_1 = __pyx_v_self->grid; + __PYX_INC_MEMVIEW(&__pyx_t_1, 1); + __pyx_v_grid_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "blokus_gym/core/blokus_cython.pyx":97 + * """Get all squares occupied by a player.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid + * cdef int size = self.size # <<<<<<<<<<<<<< + * cdef list result = [] + * cdef int x, y +*/ + __pyx_t_2 = __pyx_v_self->size; + __pyx_v_size = __pyx_t_2; + + /* "blokus_gym/core/blokus_cython.pyx":98 + * cdef cnp.int8_t[:, :] grid_view = self.grid + * cdef int size = self.size + * cdef list result = [] # <<<<<<<<<<<<<< + * cdef int x, y + * +*/ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 98, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_result = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":101 + * cdef int x, y + * + * for y in range(size): # <<<<<<<<<<<<<< + * for x in range(size): + * if grid_view[y, x] == player_idx: +*/ + __pyx_t_2 = __pyx_v_size; + __pyx_t_4 = __pyx_t_2; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_y = __pyx_t_5; + + /* "blokus_gym/core/blokus_cython.pyx":102 + * + * for y in range(size): + * for x in range(size): # <<<<<<<<<<<<<< + * if grid_view[y, x] == player_idx: + * result.append((x, y)) +*/ + __pyx_t_6 = __pyx_v_size; + __pyx_t_7 = __pyx_t_6; + for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { + __pyx_v_x = __pyx_t_8; + + /* "blokus_gym/core/blokus_cython.pyx":103 + * for y in range(size): + * for x in range(size): + * if grid_view[y, x] == player_idx: # <<<<<<<<<<<<<< + * result.append((x, y)) + * return result +*/ + __pyx_t_9 = __pyx_v_y; + __pyx_t_10 = __pyx_v_x; + __pyx_t_11 = -1; + if (__pyx_t_9 < 0) { + __pyx_t_9 += __pyx_v_grid_view.shape[0]; + if (unlikely(__pyx_t_9 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_9 >= __pyx_v_grid_view.shape[0])) __pyx_t_11 = 0; + if (__pyx_t_10 < 0) { + __pyx_t_10 += __pyx_v_grid_view.shape[1]; + if (unlikely(__pyx_t_10 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_10 >= __pyx_v_grid_view.shape[1])) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 103, __pyx_L1_error) + } + __pyx_t_12 = ((*((__pyx_t_5numpy_int8_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_grid_view.data + __pyx_t_9 * __pyx_v_grid_view.strides[0]) ) + __pyx_t_10 * __pyx_v_grid_view.strides[1]) ))) == __pyx_v_player_idx); + if (__pyx_t_12) { + + /* "blokus_gym/core/blokus_cython.pyx":104 + * for x in range(size): + * if grid_view[y, x] == player_idx: + * result.append((x, y)) # <<<<<<<<<<<<<< + * return result + * +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = __Pyx_PyLong_From_int(__pyx_v_y); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_14 = PyTuple_New(2); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 104, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_13); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 1, __pyx_t_13) != (0)) __PYX_ERR(0, 104, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_13 = 0; + __pyx_t_15 = __Pyx_PyList_Append(__pyx_v_result, __pyx_t_14); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(0, 104, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":103 + * for y in range(size): + * for x in range(size): + * if grid_view[y, x] == player_idx: # <<<<<<<<<<<<<< + * result.append((x, y)) + * return result +*/ + } + } + } + + /* "blokus_gym/core/blokus_cython.pyx":105 + * if grid_view[y, x] == player_idx: + * result.append((x, y)) + * return result # <<<<<<<<<<<<<< + * + * def get_player_occupied(self, int player_idx) -> set: +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":94 + * return 0 + * + * def get_player_squares(self, int player_idx) -> list: # <<<<<<<<<<<<<< + * """Get all squares occupied by a player.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + + /* function exit code */ + __pyx_L1_error:; + __PYX_XCLEAR_MEMVIEW(&__pyx_t_1, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.get_player_squares", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_grid_view, 1); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":107 + * return result + * + * def get_player_occupied(self, int player_idx) -> set: # <<<<<<<<<<<<<< + * """Get all squares occupied by a player as a set.""" + * if player_idx not in self._occupied_cache: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_17get_player_occupied(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_16get_player_occupied, "Get all squares occupied by a player as a set."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_17get_player_occupied = {"get_player_occupied", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_17get_player_occupied, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_16get_player_occupied}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_17get_player_occupied(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + int __pyx_v_player_idx; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_player_occupied (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_player_idx,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 107, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 107, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_player_occupied", 0) < (0)) __PYX_ERR(0, 107, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_player_occupied", 1, 1, 1, i); __PYX_ERR(0, 107, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 107, __pyx_L3_error) + } + __pyx_v_player_idx = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_player_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 107, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_player_occupied", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 107, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.get_player_occupied", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_16get_player_occupied(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self), __pyx_v_player_idx); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_16get_player_occupied(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, int __pyx_v_player_idx) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_player_occupied", 0); + + /* "blokus_gym/core/blokus_cython.pyx":109 + * def get_player_occupied(self, int player_idx) -> set: + * """Get all squares occupied by a player as a set.""" + * if player_idx not in self._occupied_cache: # <<<<<<<<<<<<<< + * self._occupied_cache[player_idx] = set(self.get_player_squares(player_idx)) + * return self._occupied_cache[player_idx] +*/ + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_player_idx); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 109, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_v_self->_occupied_cache == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 109, __pyx_L1_error) + } + __pyx_t_2 = (__Pyx_PyDict_ContainsTF(__pyx_t_1, __pyx_v_self->_occupied_cache, Py_NE)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 109, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_2) { + + /* "blokus_gym/core/blokus_cython.pyx":110 + * """Get all squares occupied by a player as a set.""" + * if player_idx not in self._occupied_cache: + * self._occupied_cache[player_idx] = set(self.get_player_squares(player_idx)) # <<<<<<<<<<<<<< + * return self._occupied_cache[player_idx] + * +*/ + __pyx_t_3 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_player_idx); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get_player_squares, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_4 = PySet_New(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(__pyx_v_self->_occupied_cache == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 110, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_player_idx); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyDict_SetItem(__pyx_v_self->_occupied_cache, __pyx_t_1, __pyx_t_4) < 0))) __PYX_ERR(0, 110, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":109 + * def get_player_occupied(self, int player_idx) -> set: + * """Get all squares occupied by a player as a set.""" + * if player_idx not in self._occupied_cache: # <<<<<<<<<<<<<< + * self._occupied_cache[player_idx] = set(self.get_player_squares(player_idx)) + * return self._occupied_cache[player_idx] +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":111 + * if player_idx not in self._occupied_cache: + * self._occupied_cache[player_idx] = set(self.get_player_squares(player_idx)) + * return self._occupied_cache[player_idx] # <<<<<<<<<<<<<< + * + * def get_player_corners(self, int player_idx) -> set: +*/ + __Pyx_XDECREF(__pyx_r); + if (unlikely(__pyx_v_self->_occupied_cache == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 111, __pyx_L1_error) + } + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_player_idx); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_self->_occupied_cache, __pyx_t_4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 111, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (!(likely(PySet_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("set", __pyx_t_1))) __PYX_ERR(0, 111, __pyx_L1_error) + __pyx_r = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":107 + * return result + * + * def get_player_occupied(self, int player_idx) -> set: # <<<<<<<<<<<<<< + * """Get all squares occupied by a player as a set.""" + * if player_idx not in self._occupied_cache: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.get_player_occupied", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":113 + * return self._occupied_cache[player_idx] + * + * def get_player_corners(self, int player_idx) -> set: # <<<<<<<<<<<<<< + * """Get all corner cells adjacent to a player's pieces.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_19get_player_corners(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_18get_player_corners, "Get all corner cells adjacent to a player's pieces."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_19get_player_corners = {"get_player_corners", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_19get_player_corners, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_18get_player_corners}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_19get_player_corners(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + int __pyx_v_player_idx; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_player_corners (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_player_idx,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 113, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 113, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_player_corners", 0) < (0)) __PYX_ERR(0, 113, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_player_corners", 1, 1, 1, i); __PYX_ERR(0, 113, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 113, __pyx_L3_error) + } + __pyx_v_player_idx = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_player_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 113, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_player_corners", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 113, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.get_player_corners", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_18get_player_corners(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self), __pyx_v_player_idx); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_18get_player_corners(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, int __pyx_v_player_idx) { + __Pyx_memviewslice __pyx_v_grid_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_v_size; + PyObject *__pyx_v_corners = 0; + PyObject *__pyx_v_player_squares = 0; + int __pyx_v_x; + int __pyx_v_y; + int __pyx_v_dx; + int __pyx_v_dy; + int __pyx_v_cx; + int __pyx_v_cy; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1 = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + Py_ssize_t __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *(*__pyx_t_10)(PyObject *); + int __pyx_t_11; + Py_ssize_t __pyx_t_12; + int __pyx_t_13; + int __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + int __pyx_t_17; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_player_corners", 0); + + /* "blokus_gym/core/blokus_cython.pyx":115 + * def get_player_corners(self, int player_idx) -> set: + * """Get all corner cells adjacent to a player's pieces.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid # <<<<<<<<<<<<<< + * cdef int size = self.size + * cdef set corners = set() +*/ + if (unlikely(!__pyx_v_self->grid.memview)) {PyErr_SetString(PyExc_AttributeError,"Memoryview is not initialized");__PYX_ERR(0, 115, __pyx_L1_error)} + __pyx_t_1 = __pyx_v_self->grid; + __PYX_INC_MEMVIEW(&__pyx_t_1, 1); + __pyx_v_grid_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "blokus_gym/core/blokus_cython.pyx":116 + * """Get all corner cells adjacent to a player's pieces.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid + * cdef int size = self.size # <<<<<<<<<<<<<< + * cdef set corners = set() + * cdef list player_squares = self.get_player_squares(player_idx) +*/ + __pyx_t_2 = __pyx_v_self->size; + __pyx_v_size = __pyx_t_2; + + /* "blokus_gym/core/blokus_cython.pyx":117 + * cdef cnp.int8_t[:, :] grid_view = self.grid + * cdef int size = self.size + * cdef set corners = set() # <<<<<<<<<<<<<< + * cdef list player_squares = self.get_player_squares(player_idx) + * cdef int x, y, dx, dy, cx, cy +*/ + __pyx_t_3 = PySet_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_corners = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":118 + * cdef int size = self.size + * cdef set corners = set() + * cdef list player_squares = self.get_player_squares(player_idx) # <<<<<<<<<<<<<< + * cdef int x, y, dx, dy, cx, cy + * +*/ + __pyx_t_4 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_player_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_5}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get_player_squares, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + if (!(likely(PyList_CheckExact(__pyx_t_3))||((__pyx_t_3) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_3))) __PYX_ERR(0, 118, __pyx_L1_error) + __pyx_v_player_squares = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":121 + * cdef int x, y, dx, dy, cx, cy + * + * for x, y in player_squares: # <<<<<<<<<<<<<< + * for dx, dy in [(-1, -1), (1, -1), (-1, 1), (1, 1)]: + * cx, cy = x + dx, y + dy +*/ + if (unlikely(__pyx_v_player_squares == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 121, __pyx_L1_error) + } + __pyx_t_3 = __pyx_v_player_squares; __Pyx_INCREF(__pyx_t_3); + __pyx_t_7 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 121, __pyx_L1_error) + #endif + if (__pyx_t_7 >= __pyx_temp) break; + } + __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_3, __pyx_t_7, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_7; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) { + PyObject* sequence = __pyx_t_5; + 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(0, 121, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_4); + __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_8); + } else { + __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_8); + } + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_9 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_10 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_9); + index = 0; __pyx_t_4 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_4)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + index = 1; __pyx_t_8 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_8)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 2) < (0)) __PYX_ERR(0, 121, __pyx_L1_error) + __pyx_t_10 = NULL; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L6_unpacking_done; + __pyx_L5_unpacking_failed:; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_10 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 121, __pyx_L1_error) + __pyx_L6_unpacking_done:; + } + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_4); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_11 = __Pyx_PyLong_As_int(__pyx_t_8); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 121, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_v_x = __pyx_t_2; + __pyx_v_y = __pyx_t_11; + + /* "blokus_gym/core/blokus_cython.pyx":122 + * + * for x, y in player_squares: + * for dx, dy in [(-1, -1), (1, -1), (-1, 1), (1, 1)]: # <<<<<<<<<<<<<< + * cx, cy = x + dx, y + dy + * if 0 <= cx < size and 0 <= cy < size and grid_view[cy, cx] == 0: +*/ + __pyx_t_5 = __pyx_mstate_global->__pyx_tuple[5]; __Pyx_INCREF(__pyx_t_5); + __pyx_t_12 = 0; + for (;;) { + if (__pyx_t_12 >= 4) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_5, __pyx_t_12)); + #else + __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_5, __pyx_t_12); + #endif + ++__pyx_t_12; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (likely(__pyx_t_8 != Py_None)) { + PyObject* sequence = __pyx_t_8; + Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 122, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_4); + __pyx_t_9 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_9); + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(0, 122, __pyx_L1_error) + } + __pyx_t_11 = __Pyx_PyLong_As_int(__pyx_t_4); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 122, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_9); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 122, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_dx = __pyx_t_11; + __pyx_v_dy = __pyx_t_2; + + /* "blokus_gym/core/blokus_cython.pyx":123 + * for x, y in player_squares: + * for dx, dy in [(-1, -1), (1, -1), (-1, 1), (1, 1)]: + * cx, cy = x + dx, y + dy # <<<<<<<<<<<<<< + * if 0 <= cx < size and 0 <= cy < size and grid_view[cy, cx] == 0: + * corners.add((cx, cy)) +*/ + __pyx_t_2 = (__pyx_v_x + __pyx_v_dx); + __pyx_t_11 = (__pyx_v_y + __pyx_v_dy); + __pyx_v_cx = __pyx_t_2; + __pyx_v_cy = __pyx_t_11; + + /* "blokus_gym/core/blokus_cython.pyx":124 + * for dx, dy in [(-1, -1), (1, -1), (-1, 1), (1, 1)]: + * cx, cy = x + dx, y + dy + * if 0 <= cx < size and 0 <= cy < size and grid_view[cy, cx] == 0: # <<<<<<<<<<<<<< + * corners.add((cx, cy)) + * return corners +*/ + __pyx_t_14 = (0 <= __pyx_v_cx); + if (__pyx_t_14) { + __pyx_t_14 = (__pyx_v_cx < __pyx_v_size); + } + if (__pyx_t_14) { + } else { + __pyx_t_13 = __pyx_t_14; + goto __pyx_L10_bool_binop_done; + } + __pyx_t_14 = (0 <= __pyx_v_cy); + if (__pyx_t_14) { + __pyx_t_14 = (__pyx_v_cy < __pyx_v_size); + } + if (__pyx_t_14) { + } else { + __pyx_t_13 = __pyx_t_14; + goto __pyx_L10_bool_binop_done; + } + __pyx_t_15 = __pyx_v_cy; + __pyx_t_16 = __pyx_v_cx; + __pyx_t_11 = -1; + if (__pyx_t_15 < 0) { + __pyx_t_15 += __pyx_v_grid_view.shape[0]; + if (unlikely(__pyx_t_15 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_15 >= __pyx_v_grid_view.shape[0])) __pyx_t_11 = 0; + if (__pyx_t_16 < 0) { + __pyx_t_16 += __pyx_v_grid_view.shape[1]; + if (unlikely(__pyx_t_16 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_16 >= __pyx_v_grid_view.shape[1])) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 124, __pyx_L1_error) + } + __pyx_t_14 = ((*((__pyx_t_5numpy_int8_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_grid_view.data + __pyx_t_15 * __pyx_v_grid_view.strides[0]) ) + __pyx_t_16 * __pyx_v_grid_view.strides[1]) ))) == 0); + __pyx_t_13 = __pyx_t_14; + __pyx_L10_bool_binop_done:; + if (__pyx_t_13) { + + /* "blokus_gym/core/blokus_cython.pyx":125 + * cx, cy = x + dx, y + dy + * if 0 <= cx < size and 0 <= cy < size and grid_view[cy, cx] == 0: + * corners.add((cx, cy)) # <<<<<<<<<<<<<< + * return corners + * +*/ + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_cx); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = __Pyx_PyLong_From_int(__pyx_v_cy); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 125, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_9); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_9) != (0)) __PYX_ERR(0, 125, __pyx_L1_error); + __pyx_t_8 = 0; + __pyx_t_9 = 0; + __pyx_t_17 = PySet_Add(__pyx_v_corners, __pyx_t_4); if (unlikely(__pyx_t_17 == ((int)-1))) __PYX_ERR(0, 125, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":124 + * for dx, dy in [(-1, -1), (1, -1), (-1, 1), (1, 1)]: + * cx, cy = x + dx, y + dy + * if 0 <= cx < size and 0 <= cy < size and grid_view[cy, cx] == 0: # <<<<<<<<<<<<<< + * corners.add((cx, cy)) + * return corners +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":122 + * + * for x, y in player_squares: + * for dx, dy in [(-1, -1), (1, -1), (-1, 1), (1, 1)]: # <<<<<<<<<<<<<< + * cx, cy = x + dx, y + dy + * if 0 <= cx < size and 0 <= cy < size and grid_view[cy, cx] == 0: +*/ + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":121 + * cdef int x, y, dx, dy, cx, cy + * + * for x, y in player_squares: # <<<<<<<<<<<<<< + * for dx, dy in [(-1, -1), (1, -1), (-1, 1), (1, 1)]: + * cx, cy = x + dx, y + dy +*/ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":126 + * if 0 <= cx < size and 0 <= cy < size and grid_view[cy, cx] == 0: + * corners.add((cx, cy)) + * return corners # <<<<<<<<<<<<<< + * + * def get_occupied(self) -> set: +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_corners); + __pyx_r = __pyx_v_corners; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":113 + * return self._occupied_cache[player_idx] + * + * def get_player_corners(self, int player_idx) -> set: # <<<<<<<<<<<<<< + * """Get all corner cells adjacent to a player's pieces.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + + /* function exit code */ + __pyx_L1_error:; + __PYX_XCLEAR_MEMVIEW(&__pyx_t_1, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.get_player_corners", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_grid_view, 1); + __Pyx_XDECREF(__pyx_v_corners); + __Pyx_XDECREF(__pyx_v_player_squares); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":128 + * return corners + * + * def get_occupied(self) -> set: # <<<<<<<<<<<<<< + * """Get all occupied cells.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_21get_occupied(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_20get_occupied, "Get all occupied cells."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_21get_occupied = {"get_occupied", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_21get_occupied, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_20get_occupied}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_21get_occupied(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_occupied (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("get_occupied", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("get_occupied", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_20get_occupied(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_20get_occupied(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self) { + __Pyx_memviewslice __pyx_v_grid_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_v_size; + PyObject *__pyx_v_result = 0; + int __pyx_v_x; + int __pyx_v_y; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1 = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + Py_ssize_t __pyx_t_9; + Py_ssize_t __pyx_t_10; + int __pyx_t_11; + int __pyx_t_12; + PyObject *__pyx_t_13 = NULL; + PyObject *__pyx_t_14 = NULL; + int __pyx_t_15; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_occupied", 0); + + /* "blokus_gym/core/blokus_cython.pyx":130 + * def get_occupied(self) -> set: + * """Get all occupied cells.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid # <<<<<<<<<<<<<< + * cdef int size = self.size + * cdef set result = set() +*/ + if (unlikely(!__pyx_v_self->grid.memview)) {PyErr_SetString(PyExc_AttributeError,"Memoryview is not initialized");__PYX_ERR(0, 130, __pyx_L1_error)} + __pyx_t_1 = __pyx_v_self->grid; + __PYX_INC_MEMVIEW(&__pyx_t_1, 1); + __pyx_v_grid_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "blokus_gym/core/blokus_cython.pyx":131 + * """Get all occupied cells.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid + * cdef int size = self.size # <<<<<<<<<<<<<< + * cdef set result = set() + * cdef int x, y +*/ + __pyx_t_2 = __pyx_v_self->size; + __pyx_v_size = __pyx_t_2; + + /* "blokus_gym/core/blokus_cython.pyx":132 + * cdef cnp.int8_t[:, :] grid_view = self.grid + * cdef int size = self.size + * cdef set result = set() # <<<<<<<<<<<<<< + * cdef int x, y + * +*/ + __pyx_t_3 = PySet_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 132, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_result = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":135 + * cdef int x, y + * + * for y in range(size): # <<<<<<<<<<<<<< + * for x in range(size): + * if grid_view[y, x] != 0: +*/ + __pyx_t_2 = __pyx_v_size; + __pyx_t_4 = __pyx_t_2; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_y = __pyx_t_5; + + /* "blokus_gym/core/blokus_cython.pyx":136 + * + * for y in range(size): + * for x in range(size): # <<<<<<<<<<<<<< + * if grid_view[y, x] != 0: + * result.add((x, y)) +*/ + __pyx_t_6 = __pyx_v_size; + __pyx_t_7 = __pyx_t_6; + for (__pyx_t_8 = 0; __pyx_t_8 < __pyx_t_7; __pyx_t_8+=1) { + __pyx_v_x = __pyx_t_8; + + /* "blokus_gym/core/blokus_cython.pyx":137 + * for y in range(size): + * for x in range(size): + * if grid_view[y, x] != 0: # <<<<<<<<<<<<<< + * result.add((x, y)) + * return result +*/ + __pyx_t_9 = __pyx_v_y; + __pyx_t_10 = __pyx_v_x; + __pyx_t_11 = -1; + if (__pyx_t_9 < 0) { + __pyx_t_9 += __pyx_v_grid_view.shape[0]; + if (unlikely(__pyx_t_9 < 0)) __pyx_t_11 = 0; + } else if (unlikely(__pyx_t_9 >= __pyx_v_grid_view.shape[0])) __pyx_t_11 = 0; + if (__pyx_t_10 < 0) { + __pyx_t_10 += __pyx_v_grid_view.shape[1]; + if (unlikely(__pyx_t_10 < 0)) __pyx_t_11 = 1; + } else if (unlikely(__pyx_t_10 >= __pyx_v_grid_view.shape[1])) __pyx_t_11 = 1; + if (unlikely(__pyx_t_11 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_11); + __PYX_ERR(0, 137, __pyx_L1_error) + } + __pyx_t_12 = ((*((__pyx_t_5numpy_int8_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_grid_view.data + __pyx_t_9 * __pyx_v_grid_view.strides[0]) ) + __pyx_t_10 * __pyx_v_grid_view.strides[1]) ))) != 0); + if (__pyx_t_12) { + + /* "blokus_gym/core/blokus_cython.pyx":138 + * for x in range(size): + * if grid_view[y, x] != 0: + * result.add((x, y)) # <<<<<<<<<<<<<< + * return result + * +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_13 = __Pyx_PyLong_From_int(__pyx_v_y); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_14 = PyTuple_New(2); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 138, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_13); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_14, 1, __pyx_t_13) != (0)) __PYX_ERR(0, 138, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_13 = 0; + __pyx_t_15 = PySet_Add(__pyx_v_result, __pyx_t_14); if (unlikely(__pyx_t_15 == ((int)-1))) __PYX_ERR(0, 138, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":137 + * for y in range(size): + * for x in range(size): + * if grid_view[y, x] != 0: # <<<<<<<<<<<<<< + * result.add((x, y)) + * return result +*/ + } + } + } + + /* "blokus_gym/core/blokus_cython.pyx":139 + * if grid_view[y, x] != 0: + * result.add((x, y)) + * return result # <<<<<<<<<<<<<< + * + * def is_full(self) -> bool: +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":128 + * return corners + * + * def get_occupied(self) -> set: # <<<<<<<<<<<<<< + * """Get all occupied cells.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + + /* function exit code */ + __pyx_L1_error:; + __PYX_XCLEAR_MEMVIEW(&__pyx_t_1, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.get_occupied", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_grid_view, 1); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":141 + * return result + * + * def is_full(self) -> bool: # <<<<<<<<<<<<<< + * """Check if the board is completely full.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_23is_full(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_22is_full, "Check if the board is completely full."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_23is_full = {"is_full", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_23is_full, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_22is_full}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_23is_full(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_full (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("is_full", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("is_full", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_22is_full(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_22is_full(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self) { + __Pyx_memviewslice __pyx_v_grid_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_v_size; + int __pyx_v_x; + int __pyx_v_y; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1 = { 0, 0, { 0 }, { 0 }, { 0 } }; + 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("is_full", 0); + + /* "blokus_gym/core/blokus_cython.pyx":143 + * def is_full(self) -> bool: + * """Check if the board is completely full.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid # <<<<<<<<<<<<<< + * cdef int size = self.size + * cdef int x, y +*/ + if (unlikely(!__pyx_v_self->grid.memview)) {PyErr_SetString(PyExc_AttributeError,"Memoryview is not initialized");__PYX_ERR(0, 143, __pyx_L1_error)} + __pyx_t_1 = __pyx_v_self->grid; + __PYX_INC_MEMVIEW(&__pyx_t_1, 1); + __pyx_v_grid_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "blokus_gym/core/blokus_cython.pyx":144 + * """Check if the board is completely full.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid + * cdef int size = self.size # <<<<<<<<<<<<<< + * cdef int x, y + * +*/ + __pyx_t_2 = __pyx_v_self->size; + __pyx_v_size = __pyx_t_2; + + /* "blokus_gym/core/blokus_cython.pyx":147 + * cdef int x, y + * + * for y in range(size): # <<<<<<<<<<<<<< + * for x in range(size): + * if grid_view[y, x] == 0: +*/ + __pyx_t_2 = __pyx_v_size; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_y = __pyx_t_4; + + /* "blokus_gym/core/blokus_cython.pyx":148 + * + * for y in range(size): + * for x in range(size): # <<<<<<<<<<<<<< + * if grid_view[y, x] == 0: + * return False +*/ + __pyx_t_5 = __pyx_v_size; + __pyx_t_6 = __pyx_t_5; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_v_x = __pyx_t_7; + + /* "blokus_gym/core/blokus_cython.pyx":149 + * for y in range(size): + * for x in range(size): + * if grid_view[y, x] == 0: # <<<<<<<<<<<<<< + * return False + * return True +*/ + __pyx_t_8 = __pyx_v_y; + __pyx_t_9 = __pyx_v_x; + __pyx_t_10 = -1; + if (__pyx_t_8 < 0) { + __pyx_t_8 += __pyx_v_grid_view.shape[0]; + if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0; + } else if (unlikely(__pyx_t_8 >= __pyx_v_grid_view.shape[0])) __pyx_t_10 = 0; + if (__pyx_t_9 < 0) { + __pyx_t_9 += __pyx_v_grid_view.shape[1]; + if (unlikely(__pyx_t_9 < 0)) __pyx_t_10 = 1; + } else if (unlikely(__pyx_t_9 >= __pyx_v_grid_view.shape[1])) __pyx_t_10 = 1; + if (unlikely(__pyx_t_10 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_10); + __PYX_ERR(0, 149, __pyx_L1_error) + } + __pyx_t_11 = ((*((__pyx_t_5numpy_int8_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_grid_view.data + __pyx_t_8 * __pyx_v_grid_view.strides[0]) ) + __pyx_t_9 * __pyx_v_grid_view.strides[1]) ))) == 0); + if (__pyx_t_11) { + + /* "blokus_gym/core/blokus_cython.pyx":150 + * for x in range(size): + * if grid_view[y, x] == 0: + * return False # <<<<<<<<<<<<<< + * return True + * +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":149 + * for y in range(size): + * for x in range(size): + * if grid_view[y, x] == 0: # <<<<<<<<<<<<<< + * return False + * return True +*/ + } + } + } + + /* "blokus_gym/core/blokus_cython.pyx":151 + * if grid_view[y, x] == 0: + * return False + * return True # <<<<<<<<<<<<<< + * + * def coverage(self) -> float: +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":141 + * return result + * + * def is_full(self) -> bool: # <<<<<<<<<<<<<< + * """Check if the board is completely full.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + + /* function exit code */ + __pyx_L1_error:; + __PYX_XCLEAR_MEMVIEW(&__pyx_t_1, 1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.is_full", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_grid_view, 1); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":153 + * return True + * + * def coverage(self) -> float: # <<<<<<<<<<<<<< + * """Get the fraction of the board that is occupied.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_25coverage(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_24coverage, "Get the fraction of the board that is occupied."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_25coverage = {"coverage", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_25coverage, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_24coverage}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_25coverage(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("coverage (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("coverage", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("coverage", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_24coverage(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_24coverage(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self) { + __Pyx_memviewslice __pyx_v_grid_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_v_size; + int __pyx_v_count; + int __pyx_v_x; + int __pyx_v_y; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1 = { 0, 0, { 0 }, { 0 }, { 0 } }; + 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; + PyObject *__pyx_t_12 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("coverage", 0); + + /* "blokus_gym/core/blokus_cython.pyx":155 + * def coverage(self) -> float: + * """Get the fraction of the board that is occupied.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid # <<<<<<<<<<<<<< + * cdef int size = self.size + * cdef int count = 0 +*/ + if (unlikely(!__pyx_v_self->grid.memview)) {PyErr_SetString(PyExc_AttributeError,"Memoryview is not initialized");__PYX_ERR(0, 155, __pyx_L1_error)} + __pyx_t_1 = __pyx_v_self->grid; + __PYX_INC_MEMVIEW(&__pyx_t_1, 1); + __pyx_v_grid_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "blokus_gym/core/blokus_cython.pyx":156 + * """Get the fraction of the board that is occupied.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid + * cdef int size = self.size # <<<<<<<<<<<<<< + * cdef int count = 0 + * cdef int x, y +*/ + __pyx_t_2 = __pyx_v_self->size; + __pyx_v_size = __pyx_t_2; + + /* "blokus_gym/core/blokus_cython.pyx":157 + * cdef cnp.int8_t[:, :] grid_view = self.grid + * cdef int size = self.size + * cdef int count = 0 # <<<<<<<<<<<<<< + * cdef int x, y + * +*/ + __pyx_v_count = 0; + + /* "blokus_gym/core/blokus_cython.pyx":160 + * cdef int x, y + * + * for y in range(size): # <<<<<<<<<<<<<< + * for x in range(size): + * if grid_view[y, x] != 0: +*/ + __pyx_t_2 = __pyx_v_size; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_y = __pyx_t_4; + + /* "blokus_gym/core/blokus_cython.pyx":161 + * + * for y in range(size): + * for x in range(size): # <<<<<<<<<<<<<< + * if grid_view[y, x] != 0: + * count += 1 +*/ + __pyx_t_5 = __pyx_v_size; + __pyx_t_6 = __pyx_t_5; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_v_x = __pyx_t_7; + + /* "blokus_gym/core/blokus_cython.pyx":162 + * for y in range(size): + * for x in range(size): + * if grid_view[y, x] != 0: # <<<<<<<<<<<<<< + * count += 1 + * return count / (size * size) +*/ + __pyx_t_8 = __pyx_v_y; + __pyx_t_9 = __pyx_v_x; + __pyx_t_10 = -1; + if (__pyx_t_8 < 0) { + __pyx_t_8 += __pyx_v_grid_view.shape[0]; + if (unlikely(__pyx_t_8 < 0)) __pyx_t_10 = 0; + } else if (unlikely(__pyx_t_8 >= __pyx_v_grid_view.shape[0])) __pyx_t_10 = 0; + if (__pyx_t_9 < 0) { + __pyx_t_9 += __pyx_v_grid_view.shape[1]; + if (unlikely(__pyx_t_9 < 0)) __pyx_t_10 = 1; + } else if (unlikely(__pyx_t_9 >= __pyx_v_grid_view.shape[1])) __pyx_t_10 = 1; + if (unlikely(__pyx_t_10 != -1)) { + __Pyx_RaiseBufferIndexError(__pyx_t_10); + __PYX_ERR(0, 162, __pyx_L1_error) + } + __pyx_t_11 = ((*((__pyx_t_5numpy_int8_t *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_grid_view.data + __pyx_t_8 * __pyx_v_grid_view.strides[0]) ) + __pyx_t_9 * __pyx_v_grid_view.strides[1]) ))) != 0); + if (__pyx_t_11) { + + /* "blokus_gym/core/blokus_cython.pyx":163 + * for x in range(size): + * if grid_view[y, x] != 0: + * count += 1 # <<<<<<<<<<<<<< + * return count / (size * size) + * +*/ + __pyx_v_count = (__pyx_v_count + 1); + + /* "blokus_gym/core/blokus_cython.pyx":162 + * for y in range(size): + * for x in range(size): + * if grid_view[y, x] != 0: # <<<<<<<<<<<<<< + * count += 1 + * return count / (size * size) +*/ + } + } + } + + /* "blokus_gym/core/blokus_cython.pyx":164 + * if grid_view[y, x] != 0: + * count += 1 + * return count / (size * size) # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = (__pyx_v_size * __pyx_v_size); + if (unlikely(__pyx_t_2 == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "float division"); + __PYX_ERR(0, 164, __pyx_L1_error) + } + __pyx_t_12 = PyFloat_FromDouble((((double)__pyx_v_count) / ((double)__pyx_t_2))); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 164, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_r = __pyx_t_12; + __pyx_t_12 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":153 + * return True + * + * def coverage(self) -> float: # <<<<<<<<<<<<<< + * """Get the fraction of the board that is occupied.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + + /* function exit code */ + __pyx_L1_error:; + __PYX_XCLEAR_MEMVIEW(&__pyx_t_1, 1); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.coverage", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_grid_view, 1); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":26 + * """ + * + * cdef public int size # <<<<<<<<<<<<<< + * cdef public cnp.int8_t[:, :] grid + * cdef public dict _occupied_cache +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_4size_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_4size_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_4size___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_4size___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__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); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 26, __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("blokus_gym.core.blokus_cython.Board.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_4size_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_4size_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_4size_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_4size_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 26, __pyx_L1_error) + __pyx_v_self->size = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.size.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":27 + * + * cdef public int size + * cdef public cnp.int8_t[:, :] grid # <<<<<<<<<<<<<< + * cdef public dict _occupied_cache + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_4grid_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_4grid_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_4grid___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_4grid___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__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); + __Pyx_XDECREF(__pyx_r); + if (unlikely(!__pyx_v_self->grid.memview)) {PyErr_SetString(PyExc_AttributeError,"Memoryview is not initialized");__PYX_ERR(0, 27, __pyx_L1_error)} + __pyx_t_1 = __pyx_memoryview_fromslice(__pyx_v_self->grid, 2, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int8_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int8_t, 0);; if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 27, __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("blokus_gym.core.blokus_cython.Board.grid.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_4grid_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_4grid_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_4grid_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_4grid_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_memviewslice __pyx_t_1 = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_nn___pyx_t_5numpy_int8_t(__pyx_v_value, PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 27, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_self->grid, 0); + __pyx_v_self->grid = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __PYX_XCLEAR_MEMVIEW(&__pyx_t_1, 1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.grid.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":28 + * cdef public int size + * cdef public cnp.int8_t[:, :] grid + * cdef public dict _occupied_cache # <<<<<<<<<<<<<< + * + * def __init__(self, int size): +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_15_occupied_cache_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_15_occupied_cache_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_15_occupied_cache___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_15_occupied_cache___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_occupied_cache); + __pyx_r = __pyx_v_self->_occupied_cache; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_15_occupied_cache_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_15_occupied_cache_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_15_occupied_cache_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_15_occupied_cache_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, 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("__set__", 0); + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyDict_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("dict", __pyx_t_1))) __PYX_ERR(0, 28, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_occupied_cache); + __Pyx_DECREF(__pyx_v_self->_occupied_cache); + __pyx_v_self->_occupied_cache = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board._occupied_cache.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_15_occupied_cache_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_15_occupied_cache_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_15_occupied_cache_4__del__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_15_occupied_cache_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_occupied_cache); + __Pyx_DECREF(__pyx_v_self->_occupied_cache); + __pyx_v_self->_occupied_cache = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_27__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_27__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_27__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_27__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_26__reduce_cython__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_26__reduce_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__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; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + 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._occupied_cache, self.grid, self.size) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: +*/ + if (unlikely(!__pyx_v_self->grid.memview)) {PyErr_SetString(PyExc_AttributeError,"Memoryview is not initialized");__PYX_ERR(1, 5, __pyx_L1_error)} + __pyx_t_1 = __pyx_memoryview_fromslice(__pyx_v_self->grid, 2, (PyObject *(*)(char *)) __pyx_memview_get_nn___pyx_t_5numpy_int8_t, (int (*)(char *, PyObject *)) __pyx_memview_set_nn___pyx_t_5numpy_int8_t, 0);; if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->size); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_self->_occupied_cache); + __Pyx_GIVEREF(__pyx_v_self->_occupied_cache); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_self->_occupied_cache) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_v_state = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self._occupied_cache, self.grid, self.size) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None and _dict: + * state += (_dict,) +*/ + __pyx_t_3 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_dict, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v__dict = __pyx_t_3; + __pyx_t_3 = 0; + + /* "(tree fragment)":7 + * state = (self._occupied_cache, self.grid, self.size) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + __pyx_t_5 = (__pyx_v__dict != Py_None); + if (__pyx_t_5) { + } else { + __pyx_t_4 = __pyx_t_5; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v__dict); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 7, __pyx_L1_error) + __pyx_t_4 = __pyx_t_5; + __pyx_L4_bool_binop_done:; + if (__pyx_t_4) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: +*/ + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v__dict) != (0)) __PYX_ERR(1, 8, __pyx_L1_error); + __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "(tree fragment)":9 + * if _dict is not None and _dict: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self._occupied_cache is not None +*/ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self._occupied_cache, self.grid, self.size) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self._occupied_cache is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Board, (type(self), 0x0510d2c, None), state +*/ + /*else*/ { + __pyx_t_4 = (__pyx_v_self->_occupied_cache != ((PyObject*)Py_None)); + __pyx_v_use_setstate = __pyx_t_4; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self._occupied_cache is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Board, (type(self), 0x0510d2c, None), state + * else: +*/ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self._occupied_cache is not None + * if use_setstate: + * return __pyx_unpickle_Board, (type(self), 0x0510d2c, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Board, (type(self), 0x0510d2c, state) +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Board); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_5311788); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_5311788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_int_5311788) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, Py_None) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self._occupied_cache is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Board, (type(self), 0x0510d2c, None), state + * else: +*/ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Board, (type(self), 0x0510d2c, None), state + * else: + * return __pyx_unpickle_Board, (type(self), 0x0510d2c, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Board__set_state(self, __pyx_state) +*/ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Board); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_5311788); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_5311788); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_int_5311788) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 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_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.__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_Board, (type(self), 0x0510d2c, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Board__set_state(self, __pyx_state) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_29__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_29__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_29__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_29__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 16, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(1, 16, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 16, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_28__setstate_cython__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Board_28__setstate_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Board, (type(self), 0x0510d2c, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Board__set_state(self, __pyx_state) # <<<<<<<<<<<<<< +*/ + __pyx_t_1 = __pyx_v___pyx_state; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 17, __pyx_L1_error) + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared 'not None'"); + __PYX_ERR(1, 17, __pyx_L1_error) + } + __pyx_t_2 = __pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_Board__set_state(__pyx_v_self, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Board, (type(self), 0x0510d2c, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Board__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_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Board.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":179 + * cdef public int y + * + * def __init__(self, int piece_id, int orientation_id, int x, int y): # <<<<<<<<<<<<<< + * self.piece_id = piece_id + * self.orientation_id = orientation_id +*/ + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_piece_id; + int __pyx_v_orientation_id; + int __pyx_v_x; + int __pyx_v_y; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_piece_id,&__pyx_mstate_global->__pyx_n_u_orientation_id,&__pyx_mstate_global->__pyx_n_u_x,&__pyx_mstate_global->__pyx_n_u_y,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 179, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 4: + values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 179, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 179, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 179, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 179, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < (0)) __PYX_ERR(0, 179, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, i); __PYX_ERR(0, 179, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 179, __pyx_L3_error) + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 179, __pyx_L3_error) + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 179, __pyx_L3_error) + values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 179, __pyx_L3_error) + } + __pyx_v_piece_id = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_piece_id == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 179, __pyx_L3_error) + __pyx_v_orientation_id = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_orientation_id == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 179, __pyx_L3_error) + __pyx_v_x = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_x == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 179, __pyx_L3_error) + __pyx_v_y = __Pyx_PyLong_As_int(values[3]); if (unlikely((__pyx_v_y == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 179, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 179, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Move.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move___init__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)__pyx_v_self), __pyx_v_piece_id, __pyx_v_orientation_id, __pyx_v_x, __pyx_v_y); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move___init__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_self, int __pyx_v_piece_id, int __pyx_v_orientation_id, int __pyx_v_x, int __pyx_v_y) { + int __pyx_r; + + /* "blokus_gym/core/blokus_cython.pyx":180 + * + * def __init__(self, int piece_id, int orientation_id, int x, int y): + * self.piece_id = piece_id # <<<<<<<<<<<<<< + * self.orientation_id = orientation_id + * self.x = x +*/ + __pyx_v_self->piece_id = __pyx_v_piece_id; + + /* "blokus_gym/core/blokus_cython.pyx":181 + * def __init__(self, int piece_id, int orientation_id, int x, int y): + * self.piece_id = piece_id + * self.orientation_id = orientation_id # <<<<<<<<<<<<<< + * self.x = x + * self.y = y +*/ + __pyx_v_self->orientation_id = __pyx_v_orientation_id; + + /* "blokus_gym/core/blokus_cython.pyx":182 + * self.piece_id = piece_id + * self.orientation_id = orientation_id + * self.x = x # <<<<<<<<<<<<<< + * self.y = y + * +*/ + __pyx_v_self->x = __pyx_v_x; + + /* "blokus_gym/core/blokus_cython.pyx":183 + * self.orientation_id = orientation_id + * self.x = x + * self.y = y # <<<<<<<<<<<<<< + * + * def __repr__(self): +*/ + __pyx_v_self->y = __pyx_v_y; + + /* "blokus_gym/core/blokus_cython.pyx":179 + * cdef public int y + * + * def __init__(self, int piece_id, int orientation_id, int x, int y): # <<<<<<<<<<<<<< + * self.piece_id = piece_id + * self.orientation_id = orientation_id +*/ + + /* function exit code */ + __pyx_r = 0; + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":185 + * self.y = y + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return f"Move(piece={self.piece_id}, orient={self.orientation_id}, pos=({self.x}, {self.y}))" + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_3__repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_3__repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_2__repr__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_2__repr__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_self) { + 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[9]; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "blokus_gym/core/blokus_cython.pyx":186 + * + * def __repr__(self): + * return f"Move(piece={self.piece_id}, orient={self.orientation_id}, pos=({self.x}, {self.y}))" # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyUnicode_From_int(__pyx_v_self->piece_id, 0, ' ', 'd'); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyUnicode_From_int(__pyx_v_self->orientation_id, 0, ' ', 'd'); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyUnicode_From_int(__pyx_v_self->x, 0, ' ', 'd'); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyUnicode_From_int(__pyx_v_self->y, 0, ' ', 'd'); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5[0] = __pyx_mstate_global->__pyx_kp_u_Move_piece; + __pyx_t_5[1] = __pyx_t_1; + __pyx_t_5[2] = __pyx_mstate_global->__pyx_kp_u_orient; + __pyx_t_5[3] = __pyx_t_2; + __pyx_t_5[4] = __pyx_mstate_global->__pyx_kp_u_pos; + __pyx_t_5[5] = __pyx_t_3; + __pyx_t_5[6] = __pyx_mstate_global->__pyx_kp_u__6; + __pyx_t_5[7] = __pyx_t_4; + __pyx_t_5[8] = __pyx_mstate_global->__pyx_kp_u__7; + __pyx_t_6 = __Pyx_PyUnicode_Join(__pyx_t_5, 9, 11 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 9 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 7 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 2 * 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_4), 127); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":185 + * self.y = y + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return f"Move(piece={self.piece_id}, orient={self.orientation_id}, pos=({self.x}, {self.y}))" + * +*/ + + /* 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_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Move.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":174 + * """A move in the game (piece, orientation, position).""" + * + * cdef public int piece_id # <<<<<<<<<<<<<< + * cdef public int orientation_id + * cdef public int x +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_8piece_id_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_8piece_id_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_8piece_id___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_8piece_id___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__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); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->piece_id); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 174, __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("blokus_gym.core.blokus_cython.Move.piece_id.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_8piece_id_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_8piece_id_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_8piece_id_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_8piece_id_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 174, __pyx_L1_error) + __pyx_v_self->piece_id = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Move.piece_id.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":175 + * + * cdef public int piece_id + * cdef public int orientation_id # <<<<<<<<<<<<<< + * cdef public int x + * cdef public int y +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_14orientation_id_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_14orientation_id_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_14orientation_id___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_14orientation_id___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__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); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->orientation_id); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 175, __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("blokus_gym.core.blokus_cython.Move.orientation_id.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_14orientation_id_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_14orientation_id_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_14orientation_id_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_14orientation_id_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 175, __pyx_L1_error) + __pyx_v_self->orientation_id = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Move.orientation_id.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":176 + * cdef public int piece_id + * cdef public int orientation_id + * cdef public int x # <<<<<<<<<<<<<< + * cdef public int y + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_1x_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_1x_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_1x___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_1x___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__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); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 176, __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("blokus_gym.core.blokus_cython.Move.x.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_1x_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_1x_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_1x_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_1x_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 176, __pyx_L1_error) + __pyx_v_self->x = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Move.x.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":177 + * cdef public int orientation_id + * cdef public int x + * cdef public int y # <<<<<<<<<<<<<< + * + * def __init__(self, int piece_id, int orientation_id, int x, int y): +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_1y_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_1y_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_1y___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_1y___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__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); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 177, __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("blokus_gym.core.blokus_cython.Move.y.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_1y_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_1y_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_1y_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_1y_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 177, __pyx_L1_error) + __pyx_v_self->y = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Move.y.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_5__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_4Move_5__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_5__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_4__reduce_cython__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_4__reduce_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__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; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_t_7; + 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.orientation_id, self.piece_id, self.x, self.y) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: +*/ + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->orientation_id); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->piece_id); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_self->x); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_self->y); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_v_state = ((PyObject*)__pyx_t_5); + __pyx_t_5 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.orientation_id, self.piece_id, self.x, self.y) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None and _dict: + * state += (_dict,) +*/ + __pyx_t_5 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_dict, Py_None); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_v__dict = __pyx_t_5; + __pyx_t_5 = 0; + + /* "(tree fragment)":7 + * state = (self.orientation_id, self.piece_id, self.x, self.y) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + __pyx_t_7 = (__pyx_v__dict != Py_None); + if (__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v__dict); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(1, 7, __pyx_L1_error) + __pyx_t_6 = __pyx_t_7; + __pyx_L4_bool_binop_done:; + if (__pyx_t_6) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: +*/ + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v__dict) != (0)) __PYX_ERR(1, 8, __pyx_L1_error); + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "(tree fragment)":9 + * if _dict is not None and _dict: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = False +*/ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.orientation_id, self.piece_id, self.x, self.y) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = False # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Move, (type(self), 0x4546268, None), state +*/ + /*else*/ { + __pyx_v_use_setstate = 0; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Move, (type(self), 0x4546268, None), state + * else: +*/ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = False + * if use_setstate: + * return __pyx_unpickle_Move, (type(self), 0x4546268, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Move, (type(self), 0x4546268, state) +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Move); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_72639080); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_72639080); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_mstate_global->__pyx_int_72639080) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, Py_None) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_5) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = False + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Move, (type(self), 0x4546268, None), state + * else: +*/ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Move, (type(self), 0x4546268, None), state + * else: + * return __pyx_unpickle_Move, (type(self), 0x4546268, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Move__set_state(self, __pyx_state) +*/ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Move); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_72639080); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_72639080); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_mstate_global->__pyx_int_72639080) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __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_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_5) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_5 = 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_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Move.__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_Move, (type(self), 0x4546268, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Move__set_state(self, __pyx_state) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_7__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_4Move_7__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_7__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 16, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(1, 16, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 16, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Move.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_6__setstate_cython__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_4Move_6__setstate_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Move, (type(self), 0x4546268, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Move__set_state(self, __pyx_state) # <<<<<<<<<<<<<< +*/ + __pyx_t_1 = __pyx_v___pyx_state; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 17, __pyx_L1_error) + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared 'not None'"); + __PYX_ERR(1, 17, __pyx_L1_error) + } + __pyx_t_2 = __pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_Move__set_state(__pyx_v_self, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Move, (type(self), 0x4546268, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Move__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_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Move.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":197 + * cdef public list corners + * + * def __init__(self, int piece_id, int orientation_id, list squares, list corners): # <<<<<<<<<<<<<< + * self.piece_id = piece_id + * self.orientation_id = orientation_id +*/ + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_piece_id; + int __pyx_v_orientation_id; + PyObject *__pyx_v_squares = 0; + PyObject *__pyx_v_corners = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_piece_id,&__pyx_mstate_global->__pyx_n_u_orientation_id,&__pyx_mstate_global->__pyx_n_u_squares,&__pyx_mstate_global->__pyx_n_u_corners,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 197, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 4: + values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 197, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 197, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 197, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 197, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < (0)) __PYX_ERR(0, 197, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, i); __PYX_ERR(0, 197, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 4)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 197, __pyx_L3_error) + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 197, __pyx_L3_error) + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 197, __pyx_L3_error) + values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 197, __pyx_L3_error) + } + __pyx_v_piece_id = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_piece_id == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 197, __pyx_L3_error) + __pyx_v_orientation_id = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_orientation_id == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 197, __pyx_L3_error) + __pyx_v_squares = ((PyObject*)values[2]); + __pyx_v_corners = ((PyObject*)values[3]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 4, 4, __pyx_nargs); __PYX_ERR(0, 197, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceOrientation.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_squares), (&PyList_Type), 1, "squares", 1))) __PYX_ERR(0, 197, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_corners), (&PyList_Type), 1, "corners", 1))) __PYX_ERR(0, 197, __pyx_L1_error) + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation___init__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)__pyx_v_self), __pyx_v_piece_id, __pyx_v_orientation_id, __pyx_v_squares, __pyx_v_corners); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation___init__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self, int __pyx_v_piece_id, int __pyx_v_orientation_id, PyObject *__pyx_v_squares, PyObject *__pyx_v_corners) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__", 0); + + /* "blokus_gym/core/blokus_cython.pyx":198 + * + * def __init__(self, int piece_id, int orientation_id, list squares, list corners): + * self.piece_id = piece_id # <<<<<<<<<<<<<< + * self.orientation_id = orientation_id + * self.squares = squares +*/ + __pyx_v_self->piece_id = __pyx_v_piece_id; + + /* "blokus_gym/core/blokus_cython.pyx":199 + * def __init__(self, int piece_id, int orientation_id, list squares, list corners): + * self.piece_id = piece_id + * self.orientation_id = orientation_id # <<<<<<<<<<<<<< + * self.squares = squares + * self.corners = corners +*/ + __pyx_v_self->orientation_id = __pyx_v_orientation_id; + + /* "blokus_gym/core/blokus_cython.pyx":200 + * self.piece_id = piece_id + * self.orientation_id = orientation_id + * self.squares = squares # <<<<<<<<<<<<<< + * self.corners = corners + * +*/ + __Pyx_INCREF(__pyx_v_squares); + __Pyx_GIVEREF(__pyx_v_squares); + __Pyx_GOTREF(__pyx_v_self->squares); + __Pyx_DECREF(__pyx_v_self->squares); + __pyx_v_self->squares = __pyx_v_squares; + + /* "blokus_gym/core/blokus_cython.pyx":201 + * self.orientation_id = orientation_id + * self.squares = squares + * self.corners = corners # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_INCREF(__pyx_v_corners); + __Pyx_GIVEREF(__pyx_v_corners); + __Pyx_GOTREF(__pyx_v_self->corners); + __Pyx_DECREF(__pyx_v_self->corners); + __pyx_v_self->corners = __pyx_v_corners; + + /* "blokus_gym/core/blokus_cython.pyx":197 + * cdef public list corners + * + * def __init__(self, int piece_id, int orientation_id, list squares, list corners): # <<<<<<<<<<<<<< + * self.piece_id = piece_id + * self.orientation_id = orientation_id +*/ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":192 + * """A piece in a specific orientation (before placement on board).""" + * + * cdef public int piece_id # <<<<<<<<<<<<<< + * cdef public int orientation_id + * cdef public list squares +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_8piece_id_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_8piece_id_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_8piece_id___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_8piece_id___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__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); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->piece_id); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 192, __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("blokus_gym.core.blokus_cython.PieceOrientation.piece_id.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_8piece_id_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_8piece_id_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_8piece_id_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_8piece_id_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 192, __pyx_L1_error) + __pyx_v_self->piece_id = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceOrientation.piece_id.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":193 + * + * cdef public int piece_id + * cdef public int orientation_id # <<<<<<<<<<<<<< + * cdef public list squares + * cdef public list corners +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_14orientation_id_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_14orientation_id_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_14orientation_id___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_14orientation_id___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__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); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->orientation_id); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 193, __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("blokus_gym.core.blokus_cython.PieceOrientation.orientation_id.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_14orientation_id_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_14orientation_id_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_14orientation_id_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_14orientation_id_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 193, __pyx_L1_error) + __pyx_v_self->orientation_id = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceOrientation.orientation_id.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":194 + * cdef public int piece_id + * cdef public int orientation_id + * cdef public list squares # <<<<<<<<<<<<<< + * cdef public list corners + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7squares_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7squares_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7squares___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7squares___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->squares); + __pyx_r = __pyx_v_self->squares; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7squares_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7squares_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7squares_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7squares_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self, 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("__set__", 0); + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 194, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->squares); + __Pyx_DECREF(__pyx_v_self->squares); + __pyx_v_self->squares = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceOrientation.squares.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7squares_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7squares_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7squares_4__del__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7squares_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->squares); + __Pyx_DECREF(__pyx_v_self->squares); + __pyx_v_self->squares = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":195 + * cdef public int orientation_id + * cdef public list squares + * cdef public list corners # <<<<<<<<<<<<<< + * + * def __init__(self, int piece_id, int orientation_id, list squares, list corners): +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7corners_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7corners_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7corners___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7corners___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->corners); + __pyx_r = __pyx_v_self->corners; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7corners_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7corners_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7corners_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7corners_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self, 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("__set__", 0); + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 195, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->corners); + __Pyx_DECREF(__pyx_v_self->corners); + __pyx_v_self->corners = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceOrientation.corners.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7corners_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7corners_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7corners_4__del__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7corners_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->corners); + __Pyx_DECREF(__pyx_v_self->corners); + __pyx_v_self->corners = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_16PieceOrientation_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_2__reduce_cython__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_2__reduce_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__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; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + 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.corners, self.orientation_id, self.piece_id, self.squares) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: +*/ + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->orientation_id); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->piece_id); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_self->corners); + __Pyx_GIVEREF(__pyx_v_self->corners); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_self->corners) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->squares); + __Pyx_GIVEREF(__pyx_v_self->squares); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 3, __pyx_v_self->squares) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_v_state = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.corners, self.orientation_id, self.piece_id, self.squares) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None and _dict: + * state += (_dict,) +*/ + __pyx_t_3 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_dict, Py_None); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v__dict = __pyx_t_3; + __pyx_t_3 = 0; + + /* "(tree fragment)":7 + * state = (self.corners, self.orientation_id, self.piece_id, self.squares) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + __pyx_t_5 = (__pyx_v__dict != Py_None); + if (__pyx_t_5) { + } else { + __pyx_t_4 = __pyx_t_5; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_v__dict); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(1, 7, __pyx_L1_error) + __pyx_t_4 = __pyx_t_5; + __pyx_L4_bool_binop_done:; + if (__pyx_t_4) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: +*/ + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v__dict) != (0)) __PYX_ERR(1, 8, __pyx_L1_error); + __pyx_t_2 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "(tree fragment)":9 + * if _dict is not None and _dict: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.corners is not None or self.squares is not None +*/ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.corners, self.orientation_id, self.piece_id, self.squares) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.corners is not None or self.squares is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_PieceOrientation, (type(self), 0xf86ecb3, None), state +*/ + /*else*/ { + __pyx_t_5 = (__pyx_v_self->corners != ((PyObject*)Py_None)); + if (!__pyx_t_5) { + } else { + __pyx_t_4 = __pyx_t_5; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_5 = (__pyx_v_self->squares != ((PyObject*)Py_None)); + __pyx_t_4 = __pyx_t_5; + __pyx_L6_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_4; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.corners is not None or self.squares is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PieceOrientation, (type(self), 0xf86ecb3, None), state + * else: +*/ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.corners is not None or self.squares is not None + * if use_setstate: + * return __pyx_unpickle_PieceOrientation, (type(self), 0xf86ecb3, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_PieceOrientation, (type(self), 0xf86ecb3, state) +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_PieceOrientation); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_260500659); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_260500659); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_int_260500659) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, Py_None) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.corners is not None or self.squares is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PieceOrientation, (type(self), 0xf86ecb3, None), state + * else: +*/ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_PieceOrientation, (type(self), 0xf86ecb3, None), state + * else: + * return __pyx_unpickle_PieceOrientation, (type(self), 0xf86ecb3, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PieceOrientation__set_state(self, __pyx_state) +*/ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_PieceOrientation); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_260500659); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_260500659); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_int_260500659) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_3 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 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_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceOrientation.__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_PieceOrientation, (type(self), 0xf86ecb3, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PieceOrientation__set_state(self, __pyx_state) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_16PieceOrientation_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 16, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(1, 16, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 16, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceOrientation.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_4__setstate_cython__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_16PieceOrientation_4__setstate_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":17 + * return __pyx_unpickle_PieceOrientation, (type(self), 0xf86ecb3, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PieceOrientation__set_state(self, __pyx_state) # <<<<<<<<<<<<<< +*/ + __pyx_t_1 = __pyx_v___pyx_state; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 17, __pyx_L1_error) + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared 'not None'"); + __PYX_ERR(1, 17, __pyx_L1_error) + } + __pyx_t_2 = __pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_PieceOrientation__set_state(__pyx_v_self, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PieceOrientation, (type(self), 0xf86ecb3, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PieceOrientation__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_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceOrientation.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":210 + * cdef public object squares # Use object to allow frozenset + * + * def __init__(self, str name, object squares): # <<<<<<<<<<<<<< + * self.name = name + * self.squares = squares +*/ + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_name = 0; + PyObject *__pyx_v_squares = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_name,&__pyx_mstate_global->__pyx_n_u_squares,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 210, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 210, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 210, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < (0)) __PYX_ERR(0, 210, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, i); __PYX_ERR(0, 210, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 210, __pyx_L3_error) + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 210, __pyx_L3_error) + } + __pyx_v_name = ((PyObject*)values[0]); + __pyx_v_squares = values[1]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 210, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Piece.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyUnicode_Type), 1, "name", 1))) __PYX_ERR(0, 210, __pyx_L1_error) + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece___init__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_v_self), __pyx_v_name, __pyx_v_squares); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece___init__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_self, PyObject *__pyx_v_name, PyObject *__pyx_v_squares) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__", 0); + + /* "blokus_gym/core/blokus_cython.pyx":211 + * + * def __init__(self, str name, object squares): + * self.name = name # <<<<<<<<<<<<<< + * self.squares = squares + * +*/ + __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; + + /* "blokus_gym/core/blokus_cython.pyx":212 + * def __init__(self, str name, object squares): + * self.name = name + * self.squares = squares # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_INCREF(__pyx_v_squares); + __Pyx_GIVEREF(__pyx_v_squares); + __Pyx_GOTREF(__pyx_v_self->squares); + __Pyx_DECREF(__pyx_v_self->squares); + __pyx_v_self->squares = __pyx_v_squares; + + /* "blokus_gym/core/blokus_cython.pyx":210 + * cdef public object squares # Use object to allow frozenset + * + * def __init__(self, str name, object squares): # <<<<<<<<<<<<<< + * self.name = name + * self.squares = squares +*/ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":214 + * self.squares = squares + * + * @property # <<<<<<<<<<<<<< + * def size(self) -> int: + * return len(self.squares) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_4size_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_4size_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_4size___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_4size___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "blokus_gym/core/blokus_cython.pyx":216 + * @property + * def size(self) -> int: + * return len(self.squares) # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_v_self->squares; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = PyObject_Length(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyLong_FromSsize_t(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":214 + * self.squares = squares + * + * @property # <<<<<<<<<<<<<< + * def size(self) -> int: + * return len(self.squares) +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Piece.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":207 + * """A polyomino piece defined by a set of (x, y) coordinates.""" + * + * cdef public str name # <<<<<<<<<<<<<< + * cdef public object squares # Use object to allow frozenset + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_4name_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_4name_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_4name___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_4name___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->name); + __pyx_r = __pyx_v_self->name; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_4name_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_4name_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_4name_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_self, 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("__set__", 0); + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyUnicode_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("str", __pyx_t_1))) __PYX_ERR(0, 207, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Piece.name.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_4name_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_4name_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_4name_4__del__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_4name_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":208 + * + * cdef public str name + * cdef public object squares # Use object to allow frozenset # <<<<<<<<<<<<<< + * + * def __init__(self, str name, object squares): +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_7squares_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_7squares_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_7squares___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_7squares___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->squares); + __pyx_r = __pyx_v_self->squares; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_7squares_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_7squares_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_7squares_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_7squares_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->squares); + __Pyx_DECREF(__pyx_v_self->squares); + __pyx_v_self->squares = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_7squares_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_7squares_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_7squares_4__del__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_7squares_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->squares); + __Pyx_DECREF(__pyx_v_self->squares); + __pyx_v_self->squares = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_5Piece_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_2__reduce_cython__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_2__reduce_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__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, self.squares) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: +*/ + __pyx_t_1 = PyTuple_New(2); 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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->squares); + __Pyx_GIVEREF(__pyx_v_self->squares); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_self->squares) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.name, self.squares) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None and _dict: + * state += (_dict,) +*/ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_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, self.squares) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + __pyx_t_3 = (__pyx_v__dict != Py_None); + if (__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v__dict); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 7, __pyx_L1_error) + __pyx_t_2 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: + * 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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict) != (0)) __PYX_ERR(1, 8, __pyx_L1_error); + __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 and _dict: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.name is not None or self.squares is not None +*/ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.name, self.squares) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.name is not None or self.squares is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Piece, (type(self), 0xb4de42d, None), state +*/ + /*else*/ { + __pyx_t_3 = (__pyx_v_self->name != ((PyObject*)Py_None)); + if (!__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_3 = (__pyx_v_self->squares != Py_None); + __pyx_t_2 = __pyx_t_3; + __pyx_L6_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.name is not None or self.squares is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Piece, (type(self), 0xb4de42d, None), state + * else: +*/ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.name is not None or self.squares is not None + * if use_setstate: + * return __pyx_unpickle_Piece, (type(self), 0xb4de42d, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Piece, (type(self), 0xb4de42d, state) +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Piece); 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)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_189654061); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_189654061); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_189654061) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __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 or self.squares is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Piece, (type(self), 0xb4de42d, None), state + * else: +*/ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Piece, (type(self), 0xb4de42d, None), state + * else: + * return __pyx_unpickle_Piece, (type(self), 0xb4de42d, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Piece__set_state(self, __pyx_state) +*/ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Piece); 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)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_189654061); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_189654061); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_189654061) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __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); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __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("blokus_gym.core.blokus_cython.Piece.__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_Piece, (type(self), 0xb4de42d, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Piece__set_state(self, __pyx_state) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_5Piece_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 16, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(1, 16, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 16, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Piece.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_4__setstate_cython__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_5Piece_4__setstate_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Piece, (type(self), 0xb4de42d, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Piece__set_state(self, __pyx_state) # <<<<<<<<<<<<<< +*/ + __pyx_t_1 = __pyx_v___pyx_state; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 17, __pyx_L1_error) + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared 'not None'"); + __PYX_ERR(1, 17, __pyx_L1_error) + } + __pyx_t_2 = __pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_Piece__set_state(__pyx_v_self, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Piece, (type(self), 0xb4de42d, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Piece__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_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.Piece.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":228 + * cdef public int num_orientations + * + * def __init__(self, list pieces_list): # <<<<<<<<<<<<<< + * self.pieces = pieces_list + * self.piece_names = [p.name for p in pieces_list] +*/ + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_pieces_list = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pieces_list,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 228, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 228, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < (0)) __PYX_ERR(0, 228, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, i); __PYX_ERR(0, 228, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 228, __pyx_L3_error) + } + __pyx_v_pieces_list = ((PyObject*)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 228, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceSet.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pieces_list), (&PyList_Type), 1, "pieces_list", 1))) __PYX_ERR(0, 228, __pyx_L1_error) + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet___init__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self), __pyx_v_pieces_list); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_8PieceSet_8__init___2generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ + +/* "blokus_gym/core/blokus_cython.pyx":241 + * self.orientations.append(orients) + * + * self.num_orientations = sum(len(o) for o in self.orientations) # <<<<<<<<<<<<<< + * + * @property +*/ + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_8__init___genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 241, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_10blokus_gym_4core_13blokus_cython_8PieceSet_8__init___2generator, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_init___locals_genexpr, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython); if (unlikely(!gen)) __PYX_ERR(0, 241, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceSet.__init__.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF((PyObject *)__pyx_cur_scope); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_8PieceSet_8__init___2generator(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr *__pyx_cur_scope = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L6_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(__pyx_sent_value != Py_None)) { + if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started generator"); + __PYX_ERR(0, 241, __pyx_L1_error) + } + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 241, __pyx_L1_error) } + if (unlikely(__pyx_cur_scope->__pyx_genexpr_arg_0 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 241, __pyx_L1_error) + } + __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 241, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + __pyx_t_3 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_1, __pyx_t_2, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_o); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_o, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_4 = PyObject_Length(__pyx_cur_scope->__pyx_v_o); if (unlikely(__pyx_t_4 == ((Py_ssize_t)-1))) __PYX_ERR(0, 241, __pyx_L1_error) + __pyx_t_3 = PyLong_FromSsize_t(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + __Pyx_XGIVEREF(__pyx_t_1); + __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; + __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L6_resume_from_yield:; + __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; + __pyx_cur_scope->__pyx_t_0 = 0; + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 241, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + if (__Pyx_PyErr_Occurred()) { + __Pyx_Generator_Replace_StopIteration(0); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":228 + * cdef public int num_orientations + * + * def __init__(self, list pieces_list): # <<<<<<<<<<<<<< + * self.pieces = pieces_list + * self.piece_names = [p.name for p in pieces_list] +*/ + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet___init__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self, PyObject *__pyx_v_pieces_list) { + Py_ssize_t __pyx_v_piece_id; + PyObject *__pyx_v_piece = NULL; + PyObject *__pyx_v_orients = NULL; + PyObject *__pyx_v_orient = NULL; + PyObject *__pyx_7genexpr__pyx_v_p = NULL; + PyObject *__pyx_8genexpr1__pyx_v_i = NULL; + PyObject *__pyx_8genexpr1__pyx_v_name = NULL; + PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_8PieceSet_8__init___2generator = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + Py_ssize_t __pyx_t_6; + Py_ssize_t __pyx_t_7; + int __pyx_t_8; + size_t __pyx_t_9; + int __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "blokus_gym/core/blokus_cython.pyx":229 + * + * def __init__(self, list pieces_list): + * self.pieces = pieces_list # <<<<<<<<<<<<<< + * self.piece_names = [p.name for p in pieces_list] + * self.piece_id_map = {name: i for i, name in enumerate(self.piece_names)} +*/ + __Pyx_INCREF(__pyx_v_pieces_list); + __Pyx_GIVEREF(__pyx_v_pieces_list); + __Pyx_GOTREF(__pyx_v_self->pieces); + __Pyx_DECREF(__pyx_v_self->pieces); + __pyx_v_self->pieces = __pyx_v_pieces_list; + + /* "blokus_gym/core/blokus_cython.pyx":230 + * def __init__(self, list pieces_list): + * self.pieces = pieces_list + * self.piece_names = [p.name for p in pieces_list] # <<<<<<<<<<<<<< + * self.piece_id_map = {name: i for i, name in enumerate(self.piece_names)} + * +*/ + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 230, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_v_pieces_list == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 230, __pyx_L5_error) + } + __pyx_t_2 = __pyx_v_pieces_list; __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 230, __pyx_L5_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_2, __pyx_t_3, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_3; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 230, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_7genexpr__pyx_v_p, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_7genexpr__pyx_v_p, __pyx_mstate_global->__pyx_n_u_name); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 230, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_4); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_4))) __PYX_ERR(0, 230, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_7genexpr__pyx_v_p); __pyx_7genexpr__pyx_v_p = 0; + goto __pyx_L9_exit_scope; + __pyx_L5_error:; + __Pyx_XDECREF(__pyx_7genexpr__pyx_v_p); __pyx_7genexpr__pyx_v_p = 0; + goto __pyx_L1_error; + __pyx_L9_exit_scope:; + } /* exit inner scope */ + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->piece_names); + __Pyx_DECREF(__pyx_v_self->piece_names); + __pyx_v_self->piece_names = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":231 + * self.pieces = pieces_list + * self.piece_names = [p.name for p in pieces_list] + * self.piece_id_map = {name: i for i, name in enumerate(self.piece_names)} # <<<<<<<<<<<<<< + * + * # Pre-compute all orientations for each piece +*/ + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 231, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __pyx_t_2 = __pyx_mstate_global->__pyx_int_0; + __pyx_t_4 = __pyx_v_self->piece_names; __Pyx_INCREF(__pyx_t_4); + __pyx_t_3 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 231, __pyx_L12_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_4, __pyx_t_3, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_3; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 231, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF_SET(__pyx_8genexpr1__pyx_v_name, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_INCREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_8genexpr1__pyx_v_i, __pyx_t_2); + __pyx_t_5 = __Pyx_PyLong_AddObjC(__pyx_t_2, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 231, __pyx_L12_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_2); + __pyx_t_2 = __pyx_t_5; + __pyx_t_5 = 0; + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_8genexpr1__pyx_v_name, (PyObject*)__pyx_8genexpr1__pyx_v_i))) __PYX_ERR(0, 231, __pyx_L12_error) + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_i); __pyx_8genexpr1__pyx_v_i = 0; + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_name); __pyx_8genexpr1__pyx_v_name = 0; + goto __pyx_L16_exit_scope; + __pyx_L12_error:; + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_i); __pyx_8genexpr1__pyx_v_i = 0; + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_name); __pyx_8genexpr1__pyx_v_name = 0; + goto __pyx_L1_error; + __pyx_L16_exit_scope:; + } /* exit inner scope */ + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->piece_id_map); + __Pyx_DECREF(__pyx_v_self->piece_id_map); + __pyx_v_self->piece_id_map = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":234 + * + * # Pre-compute all orientations for each piece + * self.orientations = [] # <<<<<<<<<<<<<< + * for piece_id, piece in enumerate(pieces_list): + * orients = generate_orientations_cython(piece) +*/ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->orientations); + __Pyx_DECREF(__pyx_v_self->orientations); + __pyx_v_self->orientations = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":235 + * # Pre-compute all orientations for each piece + * self.orientations = [] + * for piece_id, piece in enumerate(pieces_list): # <<<<<<<<<<<<<< + * orients = generate_orientations_cython(piece) + * for orient in orients: +*/ + __pyx_t_3 = 0; + __pyx_t_1 = __pyx_v_pieces_list; __Pyx_INCREF(__pyx_t_1); + __pyx_t_6 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 235, __pyx_L1_error) + #endif + if (__pyx_t_6 >= __pyx_temp) break; + } + __pyx_t_2 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_1, __pyx_t_6, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_6; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 235, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_piece, __pyx_t_2); + __pyx_t_2 = 0; + __pyx_v_piece_id = __pyx_t_3; + __pyx_t_3 = (__pyx_t_3 + 1); + + /* "blokus_gym/core/blokus_cython.pyx":236 + * self.orientations = [] + * for piece_id, piece in enumerate(pieces_list): + * orients = generate_orientations_cython(piece) # <<<<<<<<<<<<<< + * for orient in orients: + * orient.piece_id = piece_id +*/ + if (!(likely(((__pyx_v_piece) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_piece, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece))))) __PYX_ERR(0, 236, __pyx_L1_error) + __pyx_t_2 = __pyx_f_10blokus_gym_4core_13blokus_cython_generate_orientations_cython(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_v_piece)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_orients, ((PyObject*)__pyx_t_2)); + __pyx_t_2 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":237 + * for piece_id, piece in enumerate(pieces_list): + * orients = generate_orientations_cython(piece) + * for orient in orients: # <<<<<<<<<<<<<< + * orient.piece_id = piece_id + * self.orientations.append(orients) +*/ + if (unlikely(__pyx_v_orients == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 237, __pyx_L1_error) + } + __pyx_t_2 = __pyx_v_orients; __Pyx_INCREF(__pyx_t_2); + __pyx_t_7 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 237, __pyx_L1_error) + #endif + if (__pyx_t_7 >= __pyx_temp) break; + } + __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_2, __pyx_t_7, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_7; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 237, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_orient, __pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":238 + * orients = generate_orientations_cython(piece) + * for orient in orients: + * orient.piece_id = piece_id # <<<<<<<<<<<<<< + * self.orientations.append(orients) + * +*/ + __pyx_t_4 = PyLong_FromSsize_t(__pyx_v_piece_id); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_PyObject_SetAttrStr(__pyx_v_orient, __pyx_mstate_global->__pyx_n_u_piece_id, __pyx_t_4) < (0)) __PYX_ERR(0, 238, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":237 + * for piece_id, piece in enumerate(pieces_list): + * orients = generate_orientations_cython(piece) + * for orient in orients: # <<<<<<<<<<<<<< + * orient.piece_id = piece_id + * self.orientations.append(orients) +*/ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":239 + * for orient in orients: + * orient.piece_id = piece_id + * self.orientations.append(orients) # <<<<<<<<<<<<<< + * + * self.num_orientations = sum(len(o) for o in self.orientations) +*/ + if (unlikely(__pyx_v_self->orientations == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append"); + __PYX_ERR(0, 239, __pyx_L1_error) + } + __pyx_t_8 = __Pyx_PyList_Append(__pyx_v_self->orientations, __pyx_v_orients); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(0, 239, __pyx_L1_error) + + /* "blokus_gym/core/blokus_cython.pyx":235 + * # Pre-compute all orientations for each piece + * self.orientations = [] + * for piece_id, piece in enumerate(pieces_list): # <<<<<<<<<<<<<< + * orients = generate_orientations_cython(piece) + * for orient in orients: +*/ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":241 + * self.orientations.append(orients) + * + * self.num_orientations = sum(len(o) for o in self.orientations) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_t_2 = NULL; + __pyx_t_4 = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_8__init___genexpr(NULL, __pyx_v_self->orientations); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_sum, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __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(0, 241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_10 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 241, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_self->num_orientations = __pyx_t_10; + + /* "blokus_gym/core/blokus_cython.pyx":228 + * cdef public int num_orientations + * + * def __init__(self, list pieces_list): # <<<<<<<<<<<<<< + * self.pieces = pieces_list + * self.piece_names = [p.name for p in pieces_list] +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceSet.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_piece); + __Pyx_XDECREF(__pyx_v_orients); + __Pyx_XDECREF(__pyx_v_orient); + __Pyx_XDECREF(__pyx_7genexpr__pyx_v_p); + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_i); + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_name); + __Pyx_XDECREF(__pyx_gb_10blokus_gym_4core_13blokus_cython_8PieceSet_8__init___2generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":243 + * self.num_orientations = sum(len(o) for o in self.orientations) + * + * @property # <<<<<<<<<<<<<< + * def num_pieces(self) -> int: + * return len(self.pieces) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_10num_pieces_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_10num_pieces_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_10num_pieces___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_10num_pieces___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "blokus_gym/core/blokus_cython.pyx":245 + * @property + * def num_pieces(self) -> int: + * return len(self.pieces) # <<<<<<<<<<<<<< + * + * def get_orientations(self, int piece_id) -> list: +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_v_self->pieces; + __Pyx_INCREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(0, 245, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyList_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 245, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyLong_FromSsize_t(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":243 + * self.num_orientations = sum(len(o) for o in self.orientations) + * + * @property # <<<<<<<<<<<<<< + * def num_pieces(self) -> int: + * return len(self.pieces) +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceSet.num_pieces.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":247 + * return len(self.pieces) + * + * def get_orientations(self, int piece_id) -> list: # <<<<<<<<<<<<<< + * return self.orientations[piece_id] + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_3get_orientations(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_8PieceSet_3get_orientations = {"get_orientations", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_3get_orientations, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_3get_orientations(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + int __pyx_v_piece_id; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_orientations (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_piece_id,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 247, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 247, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_orientations", 0) < (0)) __PYX_ERR(0, 247, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_orientations", 1, 1, 1, i); __PYX_ERR(0, 247, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 247, __pyx_L3_error) + } + __pyx_v_piece_id = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_piece_id == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 247, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_orientations", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 247, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceSet.get_orientations", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_2get_orientations(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self), __pyx_v_piece_id); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_2get_orientations(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self, int __pyx_v_piece_id) { + 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_orientations", 0); + + /* "blokus_gym/core/blokus_cython.pyx":248 + * + * def get_orientations(self, int piece_id) -> list: + * return self.orientations[piece_id] # <<<<<<<<<<<<<< + * + * def get_piece(self, int piece_id) -> Piece: +*/ + __Pyx_XDECREF(__pyx_r); + if (unlikely(__pyx_v_self->orientations == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 248, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_self->orientations, __pyx_v_piece_id, int, 1, __Pyx_PyLong_From_int, 1, 1, 1, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 248, __pyx_L1_error) + __pyx_r = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":247 + * return len(self.pieces) + * + * def get_orientations(self, int piece_id) -> list: # <<<<<<<<<<<<<< + * return self.orientations[piece_id] + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceSet.get_orientations", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":250 + * return self.orientations[piece_id] + * + * def get_piece(self, int piece_id) -> Piece: # <<<<<<<<<<<<<< + * return self.pieces[piece_id] + * +*/ + +/* Python wrapper */ +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_5get_piece(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_8PieceSet_5get_piece = {"get_piece", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_5get_piece, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_5get_piece(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + int __pyx_v_piece_id; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_piece (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_piece_id,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 250, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 250, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_piece", 0) < (0)) __PYX_ERR(0, 250, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_piece", 1, 1, 1, i); __PYX_ERR(0, 250, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 250, __pyx_L3_error) + } + __pyx_v_piece_id = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_piece_id == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 250, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_piece", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 250, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceSet.get_piece", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_4get_piece(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self), __pyx_v_piece_id); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_4get_piece(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self, int __pyx_v_piece_id) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__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_piece", 0); + + /* "blokus_gym/core/blokus_cython.pyx":251 + * + * def get_piece(self, int piece_id) -> Piece: + * return self.pieces[piece_id] # <<<<<<<<<<<<<< + * + * def get_piece_id(self, str name) -> int: +*/ + __Pyx_XDECREF((PyObject *)__pyx_r); + if (unlikely(__pyx_v_self->pieces == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 251, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_self->pieces, __pyx_v_piece_id, int, 1, __Pyx_PyLong_From_int, 1, 1, 1, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 251, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece))))) __PYX_ERR(0, 251, __pyx_L1_error) + __pyx_r = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":250 + * return self.orientations[piece_id] + * + * def get_piece(self, int piece_id) -> Piece: # <<<<<<<<<<<<<< + * return self.pieces[piece_id] + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceSet.get_piece", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":253 + * return self.pieces[piece_id] + * + * def get_piece_id(self, str name) -> int: # <<<<<<<<<<<<<< + * return self.piece_id_map[name] + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_7get_piece_id(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_8PieceSet_7get_piece_id = {"get_piece_id", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_7get_piece_id, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_7get_piece_id(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v_name = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_piece_id (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_name,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 253, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 253, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_piece_id", 0) < (0)) __PYX_ERR(0, 253, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_piece_id", 1, 1, 1, i); __PYX_ERR(0, 253, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 253, __pyx_L3_error) + } + __pyx_v_name = ((PyObject*)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_piece_id", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 253, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceSet.get_piece_id", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_name), (&PyUnicode_Type), 1, "name", 1))) __PYX_ERR(0, 253, __pyx_L1_error) + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_6get_piece_id(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self), __pyx_v_name); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_6get_piece_id(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self, PyObject *__pyx_v_name) { + 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_piece_id", 0); + + /* "blokus_gym/core/blokus_cython.pyx":254 + * + * def get_piece_id(self, str name) -> int: + * return self.piece_id_map[name] # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_XDECREF(__pyx_r); + if (unlikely(__pyx_v_self->piece_id_map == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 254, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyDict_GetItem(__pyx_v_self->piece_id_map, __pyx_v_name); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_PyInt_FromNumber(&__pyx_t_1, NULL, 1) < (0)) __PYX_ERR(0, 254, __pyx_L1_error) + __pyx_r = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":253 + * return self.pieces[piece_id] + * + * def get_piece_id(self, str name) -> int: # <<<<<<<<<<<<<< + * return self.piece_id_map[name] + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceSet.get_piece_id", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":222 + * """A collection of pieces with pre-computed orientations.""" + * + * cdef public list pieces # <<<<<<<<<<<<<< + * cdef public list piece_names + * cdef public dict piece_id_map +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_6pieces_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_6pieces_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_6pieces___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_6pieces___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->pieces); + __pyx_r = __pyx_v_self->pieces; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_6pieces_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_6pieces_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_6pieces_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_6pieces_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self, 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("__set__", 0); + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 222, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->pieces); + __Pyx_DECREF(__pyx_v_self->pieces); + __pyx_v_self->pieces = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceSet.pieces.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_6pieces_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_6pieces_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_6pieces_4__del__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_6pieces_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->pieces); + __Pyx_DECREF(__pyx_v_self->pieces); + __pyx_v_self->pieces = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":223 + * + * cdef public list pieces + * cdef public list piece_names # <<<<<<<<<<<<<< + * cdef public dict piece_id_map + * cdef public list orientations +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_11piece_names_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_11piece_names_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_11piece_names___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_11piece_names___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->piece_names); + __pyx_r = __pyx_v_self->piece_names; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_11piece_names_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_11piece_names_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_11piece_names_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_11piece_names_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self, 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("__set__", 0); + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 223, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->piece_names); + __Pyx_DECREF(__pyx_v_self->piece_names); + __pyx_v_self->piece_names = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceSet.piece_names.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_11piece_names_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_11piece_names_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_11piece_names_4__del__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_11piece_names_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->piece_names); + __Pyx_DECREF(__pyx_v_self->piece_names); + __pyx_v_self->piece_names = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":224 + * cdef public list pieces + * cdef public list piece_names + * cdef public dict piece_id_map # <<<<<<<<<<<<<< + * cdef public list orientations + * cdef public int num_orientations +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_12piece_id_map_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_12piece_id_map_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_12piece_id_map___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_12piece_id_map___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->piece_id_map); + __pyx_r = __pyx_v_self->piece_id_map; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_12piece_id_map_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_12piece_id_map_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_12piece_id_map_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_12piece_id_map_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self, 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("__set__", 0); + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyDict_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("dict", __pyx_t_1))) __PYX_ERR(0, 224, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->piece_id_map); + __Pyx_DECREF(__pyx_v_self->piece_id_map); + __pyx_v_self->piece_id_map = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceSet.piece_id_map.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_12piece_id_map_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_12piece_id_map_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_12piece_id_map_4__del__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_12piece_id_map_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->piece_id_map); + __Pyx_DECREF(__pyx_v_self->piece_id_map); + __pyx_v_self->piece_id_map = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":225 + * cdef public list piece_names + * cdef public dict piece_id_map + * cdef public list orientations # <<<<<<<<<<<<<< + * cdef public int num_orientations + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_12orientations_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_12orientations_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_12orientations___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_12orientations___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->orientations); + __pyx_r = __pyx_v_self->orientations; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_12orientations_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_12orientations_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_12orientations_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_12orientations_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self, 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("__set__", 0); + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 225, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->orientations); + __Pyx_DECREF(__pyx_v_self->orientations); + __pyx_v_self->orientations = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceSet.orientations.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_12orientations_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_12orientations_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_12orientations_4__del__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_12orientations_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->orientations); + __Pyx_DECREF(__pyx_v_self->orientations); + __pyx_v_self->orientations = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":226 + * cdef public dict piece_id_map + * cdef public list orientations + * cdef public int num_orientations # <<<<<<<<<<<<<< + * + * def __init__(self, list pieces_list): +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_16num_orientations_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_16num_orientations_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_16num_orientations___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_16num_orientations___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__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); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->num_orientations); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 226, __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("blokus_gym.core.blokus_cython.PieceSet.num_orientations.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_16num_orientations_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_16num_orientations_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_16num_orientations_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_16num_orientations_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 226, __pyx_L1_error) + __pyx_v_self->num_orientations = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceSet.num_orientations.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_9__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_8PieceSet_9__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_9__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_8__reduce_cython__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_8__reduce_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__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; + PyObject *__pyx_t_2 = NULL; + int __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("__reduce_cython__", 0); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.num_orientations, self.orientations, self.piece_id_map, self.piece_names, self.pieces) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: +*/ + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->num_orientations); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(5); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->orientations); + __Pyx_GIVEREF(__pyx_v_self->orientations); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_v_self->orientations) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->piece_id_map); + __Pyx_GIVEREF(__pyx_v_self->piece_id_map); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_self->piece_id_map) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->piece_names); + __Pyx_GIVEREF(__pyx_v_self->piece_names); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 3, __pyx_v_self->piece_names) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->pieces); + __Pyx_GIVEREF(__pyx_v_self->pieces); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 4, __pyx_v_self->pieces) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_v_state = ((PyObject*)__pyx_t_2); + __pyx_t_2 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.num_orientations, self.orientations, self.piece_id_map, self.piece_names, self.pieces) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None and _dict: + * state += (_dict,) +*/ + __pyx_t_2 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_dict, Py_None); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_v__dict = __pyx_t_2; + __pyx_t_2 = 0; + + /* "(tree fragment)":7 + * state = (self.num_orientations, self.orientations, self.piece_id_map, self.piece_names, self.pieces) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + __pyx_t_4 = (__pyx_v__dict != Py_None); + if (__pyx_t_4) { + } else { + __pyx_t_3 = __pyx_t_4; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v__dict); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(1, 7, __pyx_L1_error) + __pyx_t_3 = __pyx_t_4; + __pyx_L4_bool_binop_done:; + if (__pyx_t_3) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: +*/ + __pyx_t_2 = PyTuple_New(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_v__dict) != (0)) __PYX_ERR(1, 8, __pyx_L1_error); + __pyx_t_1 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "(tree fragment)":9 + * if _dict is not None and _dict: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.orientations is not None or self.piece_id_map is not None or self.piece_names is not None or self.pieces is not None +*/ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.num_orientations, self.orientations, self.piece_id_map, self.piece_names, self.pieces) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.orientations is not None or self.piece_id_map is not None or self.piece_names is not None or self.pieces is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_PieceSet, (type(self), 0x0a4ef5f, None), state +*/ + /*else*/ { + __pyx_t_4 = (__pyx_v_self->orientations != ((PyObject*)Py_None)); + if (!__pyx_t_4) { + } else { + __pyx_t_3 = __pyx_t_4; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->piece_id_map != ((PyObject*)Py_None)); + if (!__pyx_t_4) { + } else { + __pyx_t_3 = __pyx_t_4; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->piece_names != ((PyObject*)Py_None)); + if (!__pyx_t_4) { + } else { + __pyx_t_3 = __pyx_t_4; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_4 = (__pyx_v_self->pieces != ((PyObject*)Py_None)); + __pyx_t_3 = __pyx_t_4; + __pyx_L6_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_3; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.orientations is not None or self.piece_id_map is not None or self.piece_names is not None or self.pieces is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PieceSet, (type(self), 0x0a4ef5f, None), state + * else: +*/ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.orientations is not None or self.piece_id_map is not None or self.piece_names is not None or self.pieces is not None + * if use_setstate: + * return __pyx_unpickle_PieceSet, (type(self), 0x0a4ef5f, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_PieceSet, (type(self), 0x0a4ef5f, state) +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_PieceSet); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_10809183); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_10809183); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_mstate_global->__pyx_int_10809183) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, Py_None) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __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_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.orientations is not None or self.piece_id_map is not None or self.piece_names is not None or self.pieces is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PieceSet, (type(self), 0x0a4ef5f, None), state + * else: +*/ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_PieceSet, (type(self), 0x0a4ef5f, None), state + * else: + * return __pyx_unpickle_PieceSet, (type(self), 0x0a4ef5f, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PieceSet__set_state(self, __pyx_state) +*/ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_PieceSet); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_10809183); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_10809183); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_mstate_global->__pyx_int_10809183) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_2) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 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_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceSet.__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_PieceSet, (type(self), 0x0a4ef5f, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PieceSet__set_state(self, __pyx_state) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_11__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_8PieceSet_11__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_11__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 16, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(1, 16, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 16, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceSet.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_10__setstate_cython__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8PieceSet_10__setstate_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":17 + * return __pyx_unpickle_PieceSet, (type(self), 0x0a4ef5f, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PieceSet__set_state(self, __pyx_state) # <<<<<<<<<<<<<< +*/ + __pyx_t_1 = __pyx_v___pyx_state; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 17, __pyx_L1_error) + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared 'not None'"); + __PYX_ERR(1, 17, __pyx_L1_error) + } + __pyx_t_2 = __pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_PieceSet__set_state(__pyx_v_self, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PieceSet, (type(self), 0x0a4ef5f, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PieceSet__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_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PieceSet.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":315 + * # ------------------------------------------------------------------- + * + * cdef list generate_orientations_cython(Piece piece): # <<<<<<<<<<<<<< + * """Generate all unique orientations of a piece.""" + * cdef set orientations_set = set() +*/ + +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython_generate_orientations_cython(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_piece) { + PyObject *__pyx_v_orientations_set = 0; + PyObject *__pyx_v_result = 0; + PyObject *__pyx_v_squares = 0; + PyObject *__pyx_v_transformed = 0; + int __pyx_v_i; + PyObject *__pyx_v_normalized = NULL; + PyObject *__pyx_v_key = NULL; + PyObject *__pyx_v_corners = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("generate_orientations_cython", 0); + + /* "blokus_gym/core/blokus_cython.pyx":317 + * cdef list generate_orientations_cython(Piece piece): + * """Generate all unique orientations of a piece.""" + * cdef set orientations_set = set() # <<<<<<<<<<<<<< + * cdef list result = [] + * cdef list squares = list(piece.squares) +*/ + __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 317, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_orientations_set = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":318 + * """Generate all unique orientations of a piece.""" + * cdef set orientations_set = set() + * cdef list result = [] # <<<<<<<<<<<<<< + * cdef list squares = list(piece.squares) + * cdef list transformed +*/ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 318, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":319 + * cdef set orientations_set = set() + * cdef list result = [] + * cdef list squares = list(piece.squares) # <<<<<<<<<<<<<< + * cdef list transformed + * cdef int i +*/ + __pyx_t_1 = PySequence_List(__pyx_v_piece->squares); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 319, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_squares = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":323 + * cdef int i + * + * for i in range(4): # 4 rotations (0, 90, 180, 270 degrees) # <<<<<<<<<<<<<< + * transformed = rotate_squares_cython(squares, i) + * normalized = normalize_squares_cython(transformed) +*/ + for (__pyx_t_2 = 0; __pyx_t_2 < 4; __pyx_t_2+=1) { + __pyx_v_i = __pyx_t_2; + + /* "blokus_gym/core/blokus_cython.pyx":324 + * + * for i in range(4): # 4 rotations (0, 90, 180, 270 degrees) + * transformed = rotate_squares_cython(squares, i) # <<<<<<<<<<<<<< + * normalized = normalize_squares_cython(transformed) + * key = tuple(normalized) +*/ + __pyx_t_1 = __pyx_f_10blokus_gym_4core_13blokus_cython_rotate_squares_cython(__pyx_v_squares, __pyx_v_i); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 324, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_transformed, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":325 + * for i in range(4): # 4 rotations (0, 90, 180, 270 degrees) + * transformed = rotate_squares_cython(squares, i) + * normalized = normalize_squares_cython(transformed) # <<<<<<<<<<<<<< + * key = tuple(normalized) + * +*/ + __pyx_t_1 = __pyx_f_10blokus_gym_4core_13blokus_cython_normalize_squares_cython(__pyx_v_transformed); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 325, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_normalized, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":326 + * transformed = rotate_squares_cython(squares, i) + * normalized = normalize_squares_cython(transformed) + * key = tuple(normalized) # <<<<<<<<<<<<<< + * + * if key not in orientations_set: +*/ + if (unlikely(__pyx_v_normalized == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 326, __pyx_L1_error) + } + __pyx_t_1 = PyList_AsTuple(__pyx_v_normalized); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 326, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_key, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":328 + * key = tuple(normalized) + * + * if key not in orientations_set: # <<<<<<<<<<<<<< + * orientations_set.add(key) + * corners = compute_corners_cython(normalized) +*/ + __pyx_t_3 = (__Pyx_PySet_ContainsTF(__pyx_v_key, __pyx_v_orientations_set, Py_NE)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(0, 328, __pyx_L1_error) + if (__pyx_t_3) { + + /* "blokus_gym/core/blokus_cython.pyx":329 + * + * if key not in orientations_set: + * orientations_set.add(key) # <<<<<<<<<<<<<< + * corners = compute_corners_cython(normalized) + * result.append(PieceOrientation(0, i, normalized, corners)) +*/ + __pyx_t_4 = PySet_Add(__pyx_v_orientations_set, __pyx_v_key); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 329, __pyx_L1_error) + + /* "blokus_gym/core/blokus_cython.pyx":330 + * if key not in orientations_set: + * orientations_set.add(key) + * corners = compute_corners_cython(normalized) # <<<<<<<<<<<<<< + * result.append(PieceOrientation(0, i, normalized, corners)) + * +*/ + __pyx_t_1 = __pyx_f_10blokus_gym_4core_13blokus_cython_compute_corners_cython(__pyx_v_normalized); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 330, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_corners, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":331 + * orientations_set.add(key) + * corners = compute_corners_cython(normalized) + * result.append(PieceOrientation(0, i, normalized, corners)) # <<<<<<<<<<<<<< + * + * return result +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_i); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 1; + { + PyObject *__pyx_callargs[5] = {__pyx_t_5, __pyx_mstate_global->__pyx_int_0, __pyx_t_6, __pyx_v_normalized, __pyx_v_corners}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation, __pyx_callargs+__pyx_t_7, (5-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 331, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + } + __pyx_t_4 = __Pyx_PyList_Append(__pyx_v_result, ((PyObject *)__pyx_t_1)); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(0, 331, __pyx_L1_error) + __Pyx_DECREF((PyObject *)__pyx_t_1); __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":328 + * key = tuple(normalized) + * + * if key not in orientations_set: # <<<<<<<<<<<<<< + * orientations_set.add(key) + * corners = compute_corners_cython(normalized) +*/ + } + } + + /* "blokus_gym/core/blokus_cython.pyx":333 + * result.append(PieceOrientation(0, i, normalized, corners)) + * + * return result # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":315 + * # ------------------------------------------------------------------- + * + * cdef list generate_orientations_cython(Piece piece): # <<<<<<<<<<<<<< + * """Generate all unique orientations of a piece.""" + * cdef set orientations_set = set() +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.generate_orientations_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_orientations_set); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_squares); + __Pyx_XDECREF(__pyx_v_transformed); + __Pyx_XDECREF(__pyx_v_normalized); + __Pyx_XDECREF(__pyx_v_key); + __Pyx_XDECREF(__pyx_v_corners); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":336 + * + * + * cdef list rotate_squares_cython(list squares, int rotations): # <<<<<<<<<<<<<< + * """Rotate squares by 90 * rotations degrees.""" + * cdef list result = [] +*/ + +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython_rotate_squares_cython(PyObject *__pyx_v_squares, int __pyx_v_rotations) { + PyObject *__pyx_v_result = 0; + int __pyx_v_x; + int __pyx_v_y; + CYTHON_UNUSED int __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __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)(PyObject *); + int __pyx_t_8; + int __pyx_t_9; + int __pyx_t_10; + int __pyx_t_11; + int __pyx_t_12; + int __pyx_t_13; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("rotate_squares_cython", 0); + + /* "blokus_gym/core/blokus_cython.pyx":338 + * cdef list rotate_squares_cython(list squares, int rotations): + * """Rotate squares by 90 * rotations degrees.""" + * cdef list result = [] # <<<<<<<<<<<<<< + * cdef int x, y, i + * +*/ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 338, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_result = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":341 + * cdef int x, y, i + * + * for x, y in squares: # <<<<<<<<<<<<<< + * for i in range(rotations): + * x, y = -y, x # 90 degree rotation +*/ + if (unlikely(__pyx_v_squares == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 341, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_squares; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 341, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + __pyx_t_3 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_1, __pyx_t_2, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 341, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + 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(0, 341, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_5); + } else { + __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 341, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 341, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_5); + } + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 341, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 341, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 341, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); + index = 0; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < (0)) __PYX_ERR(0, 341, __pyx_L1_error) + __pyx_t_7 = NULL; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L6_unpacking_done; + __pyx_L5_unpacking_failed:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 341, __pyx_L1_error) + __pyx_L6_unpacking_done:; + } + __pyx_t_8 = __Pyx_PyLong_As_int(__pyx_t_4); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 341, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_9 = __Pyx_PyLong_As_int(__pyx_t_5); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 341, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_x = __pyx_t_8; + __pyx_v_y = __pyx_t_9; + + /* "blokus_gym/core/blokus_cython.pyx":342 + * + * for x, y in squares: + * for i in range(rotations): # <<<<<<<<<<<<<< + * x, y = -y, x # 90 degree rotation + * result.append((x, y)) +*/ + __pyx_t_9 = __pyx_v_rotations; + __pyx_t_8 = __pyx_t_9; + for (__pyx_t_10 = 0; __pyx_t_10 < __pyx_t_8; __pyx_t_10+=1) { + __pyx_v_i = __pyx_t_10; + + /* "blokus_gym/core/blokus_cython.pyx":343 + * for x, y in squares: + * for i in range(rotations): + * x, y = -y, x # 90 degree rotation # <<<<<<<<<<<<<< + * result.append((x, y)) + * +*/ + __pyx_t_11 = (-__pyx_v_y); + __pyx_t_12 = __pyx_v_x; + __pyx_v_x = __pyx_t_11; + __pyx_v_y = __pyx_t_12; + } + + /* "blokus_gym/core/blokus_cython.pyx":344 + * for i in range(rotations): + * x, y = -y, x # 90 degree rotation + * result.append((x, y)) # <<<<<<<<<<<<<< + * + * return result +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 344, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 344, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 344, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 344, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 344, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_5 = 0; + __pyx_t_13 = __Pyx_PyList_Append(__pyx_v_result, __pyx_t_4); if (unlikely(__pyx_t_13 == ((int)-1))) __PYX_ERR(0, 344, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":341 + * cdef int x, y, i + * + * for x, y in squares: # <<<<<<<<<<<<<< + * for i in range(rotations): + * x, y = -y, x # 90 degree rotation +*/ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":346 + * result.append((x, y)) + * + * return result # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":336 + * + * + * cdef list rotate_squares_cython(list squares, int rotations): # <<<<<<<<<<<<<< + * """Rotate squares by 90 * rotations degrees.""" + * cdef list result = [] +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.rotate_squares_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_24normalize_squares_cython_2generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ + +/* "blokus_gym/core/blokus_cython.pyx":351 + * cdef list normalize_squares_cython(list squares): + * """Normalize squares to start at (0, 0).""" + * cdef int min_x = min(x for x, _ in squares) # <<<<<<<<<<<<<< + * cdef int min_y = min(y for _, y in squares) + * +*/ + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_24normalize_squares_cython_genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 351, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_10blokus_gym_4core_13blokus_cython_24normalize_squares_cython_2generator1, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_normalize_squares_cython_locals, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython); if (unlikely(!gen)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.normalize_squares_cython.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF((PyObject *)__pyx_cur_scope); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_24normalize_squares_cython_2generator1(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr *__pyx_cur_scope = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __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)(PyObject *); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L8_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(__pyx_sent_value != Py_None)) { + if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started generator"); + __PYX_ERR(0, 351, __pyx_L1_error) + } + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 351, __pyx_L1_error) } + if (unlikely(__pyx_cur_scope->__pyx_genexpr_arg_0 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 351, __pyx_L1_error) + } + __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 351, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + __pyx_t_3 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_1, __pyx_t_2, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + 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(0, 351, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_5); + } else { + __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_5); + } + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); + index = 0; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < (0)) __PYX_ERR(0, 351, __pyx_L1_error) + __pyx_t_7 = NULL; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L7_unpacking_done; + __pyx_L6_unpacking_failed:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 351, __pyx_L1_error) + __pyx_L7_unpacking_done:; + } + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_x); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_x, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v__); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v__, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_5); + __pyx_t_5 = 0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_x); + __pyx_r = __pyx_cur_scope->__pyx_v_x; + __Pyx_XGIVEREF(__pyx_t_1); + __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; + __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L8_resume_from_yield:; + __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; + __pyx_cur_scope->__pyx_t_0 = 0; + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 351, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + if (__Pyx_PyErr_Occurred()) { + __Pyx_Generator_Replace_StopIteration(0); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_24normalize_squares_cython_5generator2(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ + +/* "blokus_gym/core/blokus_cython.pyx":352 + * """Normalize squares to start at (0, 0).""" + * cdef int min_x = min(x for x, _ in squares) + * cdef int min_y = min(y for _, y in squares) # <<<<<<<<<<<<<< + * + * return [(x - min_x, y - min_y) for x, y in squares] +*/ + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_24normalize_squares_cython_3genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 352, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_10blokus_gym_4core_13blokus_cython_24normalize_squares_cython_5generator2, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[2]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_normalize_squares_cython_locals, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython); if (unlikely(!gen)) __PYX_ERR(0, 352, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.normalize_squares_cython.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF((PyObject *)__pyx_cur_scope); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_24normalize_squares_cython_5generator2(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr *__pyx_cur_scope = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __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)(PyObject *); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L8_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(__pyx_sent_value != Py_None)) { + if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started generator"); + __PYX_ERR(0, 352, __pyx_L1_error) + } + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 352, __pyx_L1_error) } + if (unlikely(__pyx_cur_scope->__pyx_genexpr_arg_0 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 352, __pyx_L1_error) + } + __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 352, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + __pyx_t_3 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_1, __pyx_t_2, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 352, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + 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(0, 352, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_5); + } else { + __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 352, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 352, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_5); + } + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 352, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 352, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 352, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); + index = 0; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < (0)) __PYX_ERR(0, 352, __pyx_L1_error) + __pyx_t_7 = NULL; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L7_unpacking_done; + __pyx_L6_unpacking_failed:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 352, __pyx_L1_error) + __pyx_L7_unpacking_done:; + } + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v__); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v__, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_y); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_y, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_5); + __pyx_t_5 = 0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_y); + __pyx_r = __pyx_cur_scope->__pyx_v_y; + __Pyx_XGIVEREF(__pyx_t_1); + __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; + __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L8_resume_from_yield:; + __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; + __pyx_cur_scope->__pyx_t_0 = 0; + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 352, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + if (__Pyx_PyErr_Occurred()) { + __Pyx_Generator_Replace_StopIteration(0); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":349 + * + * + * cdef list normalize_squares_cython(list squares): # <<<<<<<<<<<<<< + * """Normalize squares to start at (0, 0).""" + * cdef int min_x = min(x for x, _ in squares) +*/ + +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython_normalize_squares_cython(PyObject *__pyx_v_squares) { + int __pyx_v_min_x; + int __pyx_v_min_y; + PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_24normalize_squares_cython_2generator1 = 0; + PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_24normalize_squares_cython_5generator2 = 0; + PyObject *__pyx_8genexpr5__pyx_v_x = NULL; + PyObject *__pyx_8genexpr5__pyx_v_y = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_t_5; + Py_ssize_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *(*__pyx_t_10)(PyObject *); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("normalize_squares_cython", 0); + + /* "blokus_gym/core/blokus_cython.pyx":351 + * cdef list normalize_squares_cython(list squares): + * """Normalize squares to start at (0, 0).""" + * cdef int min_x = min(x for x, _ in squares) # <<<<<<<<<<<<<< + * cdef int min_y = min(y for _, y in squares) + * +*/ + __pyx_t_2 = NULL; + __pyx_t_3 = __pyx_pf_10blokus_gym_4core_13blokus_cython_24normalize_squares_cython_genexpr(NULL, __pyx_v_squares); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_min, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_5 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_min_x = __pyx_t_5; + + /* "blokus_gym/core/blokus_cython.pyx":352 + * """Normalize squares to start at (0, 0).""" + * cdef int min_x = min(x for x, _ in squares) + * cdef int min_y = min(y for _, y in squares) # <<<<<<<<<<<<<< + * + * return [(x - min_x, y - min_y) for x, y in squares] +*/ + __pyx_t_3 = NULL; + __pyx_t_2 = __pyx_pf_10blokus_gym_4core_13blokus_cython_24normalize_squares_cython_3genexpr(NULL, __pyx_v_squares); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 352, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_2}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_min, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 352, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_5 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_5 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 352, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_min_y = __pyx_t_5; + + /* "blokus_gym/core/blokus_cython.pyx":354 + * cdef int min_y = min(y for _, y in squares) + * + * return [(x - min_x, y - min_y) for x, y in squares] # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 354, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_v_squares == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 354, __pyx_L5_error) + } + __pyx_t_2 = __pyx_v_squares; __Pyx_INCREF(__pyx_t_2); + __pyx_t_6 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 354, __pyx_L5_error) + #endif + if (__pyx_t_6 >= __pyx_temp) break; + } + __pyx_t_3 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_2, __pyx_t_6, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_6; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 354, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + 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(0, 354, __pyx_L5_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_7 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_7); + __pyx_t_8 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_8); + } else { + __pyx_t_7 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 354, __pyx_L5_error) + __Pyx_XGOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 354, __pyx_L5_error) + __Pyx_XGOTREF(__pyx_t_8); + } + #else + __pyx_t_7 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 354, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 354, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_9 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 354, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_10 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_9); + index = 0; __pyx_t_7 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_7)) goto __pyx_L8_unpacking_failed; + __Pyx_GOTREF(__pyx_t_7); + index = 1; __pyx_t_8 = __pyx_t_10(__pyx_t_9); if (unlikely(!__pyx_t_8)) goto __pyx_L8_unpacking_failed; + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_10(__pyx_t_9), 2) < (0)) __PYX_ERR(0, 354, __pyx_L5_error) + __pyx_t_10 = NULL; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + goto __pyx_L9_unpacking_done; + __pyx_L8_unpacking_failed:; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_10 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 354, __pyx_L5_error) + __pyx_L9_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_8genexpr5__pyx_v_x, __pyx_t_7); + __pyx_t_7 = 0; + __Pyx_XDECREF_SET(__pyx_8genexpr5__pyx_v_y, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_min_x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 354, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = PyNumber_Subtract(__pyx_8genexpr5__pyx_v_x, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 354, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_min_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 354, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = PyNumber_Subtract(__pyx_8genexpr5__pyx_v_y, __pyx_t_3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 354, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 354, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 354, __pyx_L5_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 354, __pyx_L5_error); + __pyx_t_8 = 0; + __pyx_t_7 = 0; + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_3))) __PYX_ERR(0, 354, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_8genexpr5__pyx_v_x); __pyx_8genexpr5__pyx_v_x = 0; + __Pyx_XDECREF(__pyx_8genexpr5__pyx_v_y); __pyx_8genexpr5__pyx_v_y = 0; + goto __pyx_L11_exit_scope; + __pyx_L5_error:; + __Pyx_XDECREF(__pyx_8genexpr5__pyx_v_x); __pyx_8genexpr5__pyx_v_x = 0; + __Pyx_XDECREF(__pyx_8genexpr5__pyx_v_y); __pyx_8genexpr5__pyx_v_y = 0; + goto __pyx_L1_error; + __pyx_L11_exit_scope:; + } /* exit inner scope */ + __pyx_r = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":349 + * + * + * cdef list normalize_squares_cython(list squares): # <<<<<<<<<<<<<< + * """Normalize squares to start at (0, 0).""" + * cdef int min_x = min(x for x, _ in squares) +*/ + + /* 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_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.normalize_squares_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_gb_10blokus_gym_4core_13blokus_cython_24normalize_squares_cython_2generator1); + __Pyx_XDECREF(__pyx_gb_10blokus_gym_4core_13blokus_cython_24normalize_squares_cython_5generator2); + __Pyx_XDECREF(__pyx_8genexpr5__pyx_v_x); + __Pyx_XDECREF(__pyx_8genexpr5__pyx_v_y); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":357 + * + * + * cdef list compute_corners_cython(list squares): # <<<<<<<<<<<<<< + * """Compute corner squares (diagonal neighbors).""" + * cdef set corners = set() +*/ + +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython_compute_corners_cython(PyObject *__pyx_v_squares) { + PyObject *__pyx_v_corners = 0; + int __pyx_v_x; + int __pyx_v_y; + int __pyx_v_dx; + int __pyx_v_dy; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __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)(PyObject *); + int __pyx_t_8; + int __pyx_t_9; + Py_ssize_t __pyx_t_10; + int __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("compute_corners_cython", 0); + + /* "blokus_gym/core/blokus_cython.pyx":359 + * cdef list compute_corners_cython(list squares): + * """Compute corner squares (diagonal neighbors).""" + * cdef set corners = set() # <<<<<<<<<<<<<< + * cdef int x, y, dx, dy + * +*/ + __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 359, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_corners = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":362 + * cdef int x, y, dx, dy + * + * for x, y in squares: # <<<<<<<<<<<<<< + * for dx, dy in [(-1, -1), (1, -1), (-1, 1), (1, 1)]: + * corners.add((x + dx, y + dy)) +*/ + if (unlikely(__pyx_v_squares == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 362, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_squares; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 362, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + __pyx_t_3 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_1, __pyx_t_2, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + 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(0, 362, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_5); + } else { + __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 362, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 362, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_5); + } + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 362, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); + index = 0; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < (0)) __PYX_ERR(0, 362, __pyx_L1_error) + __pyx_t_7 = NULL; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L6_unpacking_done; + __pyx_L5_unpacking_failed:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 362, __pyx_L1_error) + __pyx_L6_unpacking_done:; + } + __pyx_t_8 = __Pyx_PyLong_As_int(__pyx_t_4); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 362, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_9 = __Pyx_PyLong_As_int(__pyx_t_5); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 362, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_x = __pyx_t_8; + __pyx_v_y = __pyx_t_9; + + /* "blokus_gym/core/blokus_cython.pyx":363 + * + * for x, y in squares: + * for dx, dy in [(-1, -1), (1, -1), (-1, 1), (1, 1)]: # <<<<<<<<<<<<<< + * corners.add((x + dx, y + dy)) + * +*/ + __pyx_t_3 = __pyx_mstate_global->__pyx_tuple[5]; __Pyx_INCREF(__pyx_t_3); + __pyx_t_10 = 0; + for (;;) { + if (__pyx_t_10 >= 4) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_10)); + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_10); + #endif + ++__pyx_t_10; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (likely(__pyx_t_5 != Py_None)) { + PyObject* sequence = __pyx_t_5; + Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 363, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_4); + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_6); + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(0, 363, __pyx_L1_error) + } + __pyx_t_9 = __Pyx_PyLong_As_int(__pyx_t_4); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 363, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_8 = __Pyx_PyLong_As_int(__pyx_t_6); if (unlikely((__pyx_t_8 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 363, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_v_dx = __pyx_t_9; + __pyx_v_dy = __pyx_t_8; + + /* "blokus_gym/core/blokus_cython.pyx":364 + * for x, y in squares: + * for dx, dy in [(-1, -1), (1, -1), (-1, 1), (1, 1)]: + * corners.add((x + dx, y + dy)) # <<<<<<<<<<<<<< + * + * return list(corners) +*/ + __pyx_t_5 = __Pyx_PyLong_From_int((__pyx_v_x + __pyx_v_dx)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyLong_From_int((__pyx_v_y + __pyx_v_dy)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 364, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 364, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_t_11 = PySet_Add(__pyx_v_corners, __pyx_t_4); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 364, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":363 + * + * for x, y in squares: + * for dx, dy in [(-1, -1), (1, -1), (-1, 1), (1, 1)]: # <<<<<<<<<<<<<< + * corners.add((x + dx, y + dy)) + * +*/ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":362 + * cdef int x, y, dx, dy + * + * for x, y in squares: # <<<<<<<<<<<<<< + * for dx, dy in [(-1, -1), (1, -1), (-1, 1), (1, 1)]: + * corners.add((x + dx, y + dy)) +*/ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":366 + * corners.add((x + dx, y + dy)) + * + * return list(corners) # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PySequence_List(__pyx_v_corners); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":357 + * + * + * cdef list compute_corners_cython(list squares): # <<<<<<<<<<<<<< + * """Compute corner squares (diagonal neighbors).""" + * cdef set corners = set() +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.compute_corners_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_corners); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":383 + * cdef public bint can_move + * + * def __init__(self): # <<<<<<<<<<<<<< + * self.idx = -1 + * self.available_pieces = set() +*/ + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 0, 0, __pyx_nargs); return -1; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return -1; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__init__", __pyx_kwds); return -1;} + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState___init__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState___init__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self) { + 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("__init__", 0); + + /* "blokus_gym/core/blokus_cython.pyx":384 + * + * def __init__(self): + * self.idx = -1 # <<<<<<<<<<<<<< + * self.available_pieces = set() + * self.corners = set() +*/ + __pyx_v_self->idx = -1; + + /* "blokus_gym/core/blokus_cython.pyx":385 + * def __init__(self): + * self.idx = -1 + * self.available_pieces = set() # <<<<<<<<<<<<<< + * self.corners = set() + * self.score = 0 +*/ + __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 385, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->available_pieces); + __Pyx_DECREF(__pyx_v_self->available_pieces); + __pyx_v_self->available_pieces = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":386 + * self.idx = -1 + * self.available_pieces = set() + * self.corners = set() # <<<<<<<<<<<<<< + * self.score = 0 + * self.has_started = False +*/ + __pyx_t_1 = PySet_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 386, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->corners); + __Pyx_DECREF(__pyx_v_self->corners); + __pyx_v_self->corners = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":387 + * self.available_pieces = set() + * self.corners = set() + * self.score = 0 # <<<<<<<<<<<<<< + * self.has_started = False + * self.can_move = True +*/ + __pyx_v_self->score = 0; + + /* "blokus_gym/core/blokus_cython.pyx":388 + * self.corners = set() + * self.score = 0 + * self.has_started = False # <<<<<<<<<<<<<< + * self.can_move = True + * +*/ + __pyx_v_self->has_started = 0; + + /* "blokus_gym/core/blokus_cython.pyx":389 + * self.score = 0 + * self.has_started = False + * self.can_move = True # <<<<<<<<<<<<<< + * + * +*/ + __pyx_v_self->can_move = 1; + + /* "blokus_gym/core/blokus_cython.pyx":383 + * cdef public bint can_move + * + * def __init__(self): # <<<<<<<<<<<<<< + * self.idx = -1 + * self.available_pieces = set() +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PlayerState.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":376 + * """State for a single player.""" + * + * cdef public int idx # <<<<<<<<<<<<<< + * cdef public set available_pieces + * cdef public set corners +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_3idx_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_3idx_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_3idx___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_3idx___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__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); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->idx); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 376, __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("blokus_gym.core.blokus_cython.PlayerState.idx.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_3idx_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_3idx_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_3idx_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_3idx_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 376, __pyx_L1_error) + __pyx_v_self->idx = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PlayerState.idx.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":377 + * + * cdef public int idx + * cdef public set available_pieces # <<<<<<<<<<<<<< + * cdef public set corners + * cdef public int score +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_16available_pieces_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_16available_pieces_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_16available_pieces___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_16available_pieces___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->available_pieces); + __pyx_r = __pyx_v_self->available_pieces; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_16available_pieces_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_16available_pieces_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_16available_pieces_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_16available_pieces_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self, 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("__set__", 0); + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PySet_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("set", __pyx_t_1))) __PYX_ERR(0, 377, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->available_pieces); + __Pyx_DECREF(__pyx_v_self->available_pieces); + __pyx_v_self->available_pieces = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PlayerState.available_pieces.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_16available_pieces_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_16available_pieces_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_16available_pieces_4__del__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_16available_pieces_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->available_pieces); + __Pyx_DECREF(__pyx_v_self->available_pieces); + __pyx_v_self->available_pieces = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":378 + * cdef public int idx + * cdef public set available_pieces + * cdef public set corners # <<<<<<<<<<<<<< + * cdef public int score + * cdef public bint has_started +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_7corners_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_7corners_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_7corners___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_7corners___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->corners); + __pyx_r = __pyx_v_self->corners; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_7corners_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_7corners_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_7corners_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_7corners_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self, 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("__set__", 0); + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PySet_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("set", __pyx_t_1))) __PYX_ERR(0, 378, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->corners); + __Pyx_DECREF(__pyx_v_self->corners); + __pyx_v_self->corners = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PlayerState.corners.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_7corners_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_7corners_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_7corners_4__del__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_7corners_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->corners); + __Pyx_DECREF(__pyx_v_self->corners); + __pyx_v_self->corners = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":379 + * cdef public set available_pieces + * cdef public set corners + * cdef public int score # <<<<<<<<<<<<<< + * cdef public bint has_started + * cdef public bint can_move +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_5score_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_5score_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_5score___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_5score___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__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); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->score); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 379, __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("blokus_gym.core.blokus_cython.PlayerState.score.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_5score_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_5score_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_5score_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_5score_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 379, __pyx_L1_error) + __pyx_v_self->score = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PlayerState.score.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":380 + * cdef public set corners + * cdef public int score + * cdef public bint has_started # <<<<<<<<<<<<<< + * cdef public bint can_move + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_11has_started_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_11has_started_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_11has_started___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_11has_started___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__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); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->has_started); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 380, __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("blokus_gym.core.blokus_cython.PlayerState.has_started.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_11has_started_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_11has_started_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_11has_started_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_11has_started_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 380, __pyx_L1_error) + __pyx_v_self->has_started = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PlayerState.has_started.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":381 + * cdef public int score + * cdef public bint has_started + * cdef public bint can_move # <<<<<<<<<<<<<< + * + * def __init__(self): +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_8can_move_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_8can_move_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_8can_move___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_8can_move___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__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); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->can_move); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 381, __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("blokus_gym.core.blokus_cython.PlayerState.can_move.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_8can_move_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_8can_move_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_8can_move_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_8can_move_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 381, __pyx_L1_error) + __pyx_v_self->can_move = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PlayerState.can_move.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_11PlayerState_3__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_3__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_2__reduce_cython__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_2__reduce_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__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; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_t_6; + int __pyx_t_7; + 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.available_pieces, self.can_move, self.corners, self.has_started, self.idx, self.score) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: +*/ + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->can_move); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->has_started); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_self->idx); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_self->score); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(6); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_self->available_pieces); + __Pyx_GIVEREF(__pyx_v_self->available_pieces); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_self->available_pieces) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->corners); + __Pyx_GIVEREF(__pyx_v_self->corners); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_self->corners) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_2) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, __pyx_t_3) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, __pyx_t_4) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_v_state = ((PyObject*)__pyx_t_5); + __pyx_t_5 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.available_pieces, self.can_move, self.corners, self.has_started, self.idx, self.score) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None and _dict: + * state += (_dict,) +*/ + __pyx_t_5 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_dict, Py_None); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_v__dict = __pyx_t_5; + __pyx_t_5 = 0; + + /* "(tree fragment)":7 + * state = (self.available_pieces, self.can_move, self.corners, self.has_started, self.idx, self.score) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + __pyx_t_7 = (__pyx_v__dict != Py_None); + if (__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_v__dict); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(1, 7, __pyx_L1_error) + __pyx_t_6 = __pyx_t_7; + __pyx_L4_bool_binop_done:; + if (__pyx_t_6) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: +*/ + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v__dict) != (0)) __PYX_ERR(1, 8, __pyx_L1_error); + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "(tree fragment)":9 + * if _dict is not None and _dict: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self.available_pieces is not None or self.corners is not None +*/ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.available_pieces, self.can_move, self.corners, self.has_started, self.idx, self.score) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self.available_pieces is not None or self.corners is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_PlayerState, (type(self), 0x820c4ca, None), state +*/ + /*else*/ { + __pyx_t_7 = (__pyx_v_self->available_pieces != ((PyObject*)Py_None)); + if (!__pyx_t_7) { + } else { + __pyx_t_6 = __pyx_t_7; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_7 = (__pyx_v_self->corners != ((PyObject*)Py_None)); + __pyx_t_6 = __pyx_t_7; + __pyx_L6_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_6; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.available_pieces is not None or self.corners is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PlayerState, (type(self), 0x820c4ca, None), state + * else: +*/ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self.available_pieces is not None or self.corners is not None + * if use_setstate: + * return __pyx_unpickle_PlayerState, (type(self), 0x820c4ca, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_PlayerState, (type(self), 0x820c4ca, state) +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_PlayerState); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_136365258); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_136365258); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_mstate_global->__pyx_int_136365258) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, Py_None) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_5) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self.available_pieces is not None or self.corners is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_PlayerState, (type(self), 0x820c4ca, None), state + * else: +*/ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_PlayerState, (type(self), 0x820c4ca, None), state + * else: + * return __pyx_unpickle_PlayerState, (type(self), 0x820c4ca, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PlayerState__set_state(self, __pyx_state) +*/ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_PlayerState); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_136365258); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_136365258); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_mstate_global->__pyx_int_136365258) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __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_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_5) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_5 = 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_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PlayerState.__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_PlayerState, (type(self), 0x820c4ca, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PlayerState__set_state(self, __pyx_state) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_11PlayerState_5__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_5__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 16, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(1, 16, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 16, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PlayerState.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_4__setstate_cython__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_11PlayerState_4__setstate_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":17 + * return __pyx_unpickle_PlayerState, (type(self), 0x820c4ca, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_PlayerState__set_state(self, __pyx_state) # <<<<<<<<<<<<<< +*/ + __pyx_t_1 = __pyx_v___pyx_state; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 17, __pyx_L1_error) + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared 'not None'"); + __PYX_ERR(1, 17, __pyx_L1_error) + } + __pyx_t_2 = __pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_PlayerState__set_state(__pyx_v_self, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PlayerState, (type(self), 0x820c4ca, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PlayerState__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_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.PlayerState.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":413 + * cdef public list _starting_corners + * + * def __init__(self, int board_size=20, PieceSet pieces=None, int num_players=4, bint corner_rule=True): # <<<<<<<<<<<<<< + * self.board_size = board_size + * self.piece_set = pieces or PieceSet(STANDARD_PIECES) +*/ + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_1__init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + int __pyx_v_board_size; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_pieces = 0; + int __pyx_v_num_players; + int __pyx_v_corner_rule; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[4] = {0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_board_size,&__pyx_mstate_global->__pyx_n_u_pieces,&__pyx_mstate_global->__pyx_n_u_num_players,&__pyx_mstate_global->__pyx_n_u_corner_rule,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 413, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 4: + values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 413, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 413, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 413, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 413, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < (0)) __PYX_ERR(0, 413, __pyx_L3_error) + if (!values[1]) values[1] = __Pyx_NewRef((PyObject *)((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)Py_None)); + } else { + switch (__pyx_nargs) { + case 4: + values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 413, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 413, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 413, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 413, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + if (!values[1]) values[1] = __Pyx_NewRef((PyObject *)((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)Py_None)); + } + if (values[0]) { + __pyx_v_board_size = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_board_size == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 413, __pyx_L3_error) + } else { + __pyx_v_board_size = ((int)20); + } + __pyx_v_pieces = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)values[1]); + if (values[2]) { + __pyx_v_num_players = __Pyx_PyLong_As_int(values[2]); if (unlikely((__pyx_v_num_players == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 413, __pyx_L3_error) + } else { + __pyx_v_num_players = ((int)4); + } + if (values[3]) { + __pyx_v_corner_rule = __Pyx_PyObject_IsTrue(values[3]); if (unlikely((__pyx_v_corner_rule == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 413, __pyx_L3_error) + } else { + __pyx_v_corner_rule = ((int)1); + } + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 0, 0, 4, __pyx_nargs); __PYX_ERR(0, 413, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_pieces), __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet, 1, "pieces", 0))) __PYX_ERR(0, 413, __pyx_L1_error) + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame___init__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), __pyx_v_board_size, __pyx_v_pieces, __pyx_v_num_players, __pyx_v_corner_rule); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame___init__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, int __pyx_v_board_size, struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v_pieces, int __pyx_v_num_players, int __pyx_v_corner_rule) { + PyObject *__pyx_v_piece_id = NULL; + long __pyx_v_max_idx; + int __pyx_v_i; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_player = NULL; + PyObject *__pyx_8genexpr6__pyx_v_idx = NULL; + PyObject *__pyx_8genexpr6__pyx_v_move = NULL; + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + PyObject *(*__pyx_t_6)(PyObject *); + PyObject *__pyx_t_7 = NULL; + Py_ssize_t __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + int __pyx_t_12; + int __pyx_t_13; + int __pyx_t_14; + int __pyx_t_15; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__init__", 0); + + /* "blokus_gym/core/blokus_cython.pyx":414 + * + * def __init__(self, int board_size=20, PieceSet pieces=None, int num_players=4, bint corner_rule=True): + * self.board_size = board_size # <<<<<<<<<<<<<< + * self.piece_set = pieces or PieceSet(STANDARD_PIECES) + * self.num_players = num_players +*/ + __pyx_v_self->board_size = __pyx_v_board_size; + + /* "blokus_gym/core/blokus_cython.pyx":415 + * def __init__(self, int board_size=20, PieceSet pieces=None, int num_players=4, bint corner_rule=True): + * self.board_size = board_size + * self.piece_set = pieces or PieceSet(STANDARD_PIECES) # <<<<<<<<<<<<<< + * self.num_players = num_players + * self.corner_rule = corner_rule +*/ + __pyx_t_2 = __Pyx_PyObject_IsTrue(((PyObject *)__pyx_v_pieces)); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 415, __pyx_L1_error) + if (!__pyx_t_2) { + } else { + __Pyx_INCREF((PyObject *)__pyx_v_pieces); + __pyx_t_1 = ((PyObject *)__pyx_v_pieces); + goto __pyx_L3_bool_binop_done; + } + __pyx_t_4 = NULL; + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_10blokus_gym_4core_13blokus_cython_STANDARD_PIECES}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 415, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_3); + } + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = __pyx_t_3; + __Pyx_DECREF((PyObject *)__pyx_t_3); __pyx_t_3 = 0; + __pyx_L3_bool_binop_done:; + __Pyx_GIVEREF((PyObject *)__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v_self->piece_set); + __Pyx_DECREF((PyObject *)__pyx_v_self->piece_set); + __pyx_v_self->piece_set = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":416 + * self.board_size = board_size + * self.piece_set = pieces or PieceSet(STANDARD_PIECES) + * self.num_players = num_players # <<<<<<<<<<<<<< + * self.corner_rule = corner_rule + * +*/ + __pyx_v_self->num_players = __pyx_v_num_players; + + /* "blokus_gym/core/blokus_cython.pyx":417 + * self.piece_set = pieces or PieceSet(STANDARD_PIECES) + * self.num_players = num_players + * self.corner_rule = corner_rule # <<<<<<<<<<<<<< + * + * self.board = Board(board_size) +*/ + __pyx_v_self->corner_rule = __pyx_v_corner_rule; + + /* "blokus_gym/core/blokus_cython.pyx":419 + * self.corner_rule = corner_rule + * + * self.board = Board(board_size) # <<<<<<<<<<<<<< + * self.players = [] + * self.current_player = 0 +*/ + __pyx_t_3 = NULL; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_board_size); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + } + __Pyx_GIVEREF((PyObject *)__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->board); + __Pyx_DECREF(__pyx_v_self->board); + __pyx_v_self->board = ((PyObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":420 + * + * self.board = Board(board_size) + * self.players = [] # <<<<<<<<<<<<<< + * self.current_player = 0 + * self.rounds = 0 +*/ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->players); + __Pyx_DECREF(__pyx_v_self->players); + __pyx_v_self->players = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":421 + * self.board = Board(board_size) + * self.players = [] + * self.current_player = 0 # <<<<<<<<<<<<<< + * self.rounds = 0 + * self.game_over = False +*/ + __pyx_v_self->current_player = 0; + + /* "blokus_gym/core/blokus_cython.pyx":422 + * self.players = [] + * self.current_player = 0 + * self.rounds = 0 # <<<<<<<<<<<<<< + * self.game_over = False + * +*/ + __pyx_v_self->rounds = 0; + + /* "blokus_gym/core/blokus_cython.pyx":423 + * self.current_player = 0 + * self.rounds = 0 + * self.game_over = False # <<<<<<<<<<<<<< + * + * # Pre-compute all possible moves +*/ + __pyx_v_self->game_over = 0; + + /* "blokus_gym/core/blokus_cython.pyx":426 + * + * # Pre-compute all possible moves + * self._action_moves = [] # <<<<<<<<<<<<<< + * self._move_to_action = {} + * self._generate_action_space() +*/ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 426, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_action_moves); + __Pyx_DECREF(__pyx_v_self->_action_moves); + __pyx_v_self->_action_moves = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":427 + * # Pre-compute all possible moves + * self._action_moves = [] + * self._move_to_action = {} # <<<<<<<<<<<<<< + * self._generate_action_space() + * +*/ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 427, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_move_to_action); + __Pyx_DECREF(__pyx_v_self->_move_to_action); + __pyx_v_self->_move_to_action = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":428 + * self._action_moves = [] + * self._move_to_action = {} + * self._generate_action_space() # <<<<<<<<<<<<<< + * + * # Pre-compute action indices per piece +*/ + ((struct __pyx_vtabstruct_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self->__pyx_vtab)->_generate_action_space(__pyx_v_self); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 428, __pyx_L1_error) + + /* "blokus_gym/core/blokus_cython.pyx":431 + * + * # Pre-compute action indices per piece + * self._actions_by_piece = [] # <<<<<<<<<<<<<< + * for piece_id in range(self.piece_set.num_pieces): + * self._actions_by_piece.append([ +*/ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 431, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_actions_by_piece); + __Pyx_DECREF(__pyx_v_self->_actions_by_piece); + __pyx_v_self->_actions_by_piece = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":432 + * # Pre-compute action indices per piece + * self._actions_by_piece = [] + * for piece_id in range(self.piece_set.num_pieces): # <<<<<<<<<<<<<< + * self._actions_by_piece.append([ + * idx for idx, move in enumerate(self._action_moves) +*/ + __pyx_t_4 = NULL; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->piece_set), __pyx_mstate_global->__pyx_n_u_num_pieces); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(&PyRange_Type), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 432, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + { + __pyx_t_1 = __pyx_t_6(__pyx_t_3); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 432, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_piece_id, __pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":433 + * self._actions_by_piece = [] + * for piece_id in range(self.piece_set.num_pieces): + * self._actions_by_piece.append([ # <<<<<<<<<<<<<< + * idx for idx, move in enumerate(self._action_moves) + * if move.piece_id == piece_id +*/ + if (unlikely(__pyx_v_self->_actions_by_piece == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append"); + __PYX_ERR(0, 433, __pyx_L1_error) + } + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 433, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __pyx_t_4 = __pyx_mstate_global->__pyx_int_0; + + /* "blokus_gym/core/blokus_cython.pyx":434 + * for piece_id in range(self.piece_set.num_pieces): + * self._actions_by_piece.append([ + * idx for idx, move in enumerate(self._action_moves) # <<<<<<<<<<<<<< + * if move.piece_id == piece_id + * ]) +*/ + __pyx_t_7 = __pyx_v_self->_action_moves; __Pyx_INCREF(__pyx_t_7); + __pyx_t_8 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 434, __pyx_L9_error) + #endif + if (__pyx_t_8 >= __pyx_temp) break; + } + __pyx_t_9 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_7, __pyx_t_8, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_8; + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 434, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_XDECREF_SET(__pyx_8genexpr6__pyx_v_move, __pyx_t_9); + __pyx_t_9 = 0; + __Pyx_INCREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_8genexpr6__pyx_v_idx, __pyx_t_4); + __pyx_t_9 = __Pyx_PyLong_AddObjC(__pyx_t_4, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 434, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); + __pyx_t_4 = __pyx_t_9; + __pyx_t_9 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":435 + * self._actions_by_piece.append([ + * idx for idx, move in enumerate(self._action_moves) + * if move.piece_id == piece_id # <<<<<<<<<<<<<< + * ]) + * +*/ + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_8genexpr6__pyx_v_move, __pyx_mstate_global->__pyx_n_u_piece_id); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 435, __pyx_L9_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = PyObject_RichCompare(__pyx_t_9, __pyx_v_piece_id, Py_EQ); __Pyx_XGOTREF(__pyx_t_10); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 435, __pyx_L9_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_10); if (unlikely((__pyx_t_2 < 0))) __PYX_ERR(0, 435, __pyx_L9_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (__pyx_t_2) { + + /* "blokus_gym/core/blokus_cython.pyx":434 + * for piece_id in range(self.piece_set.num_pieces): + * self._actions_by_piece.append([ + * idx for idx, move in enumerate(self._action_moves) # <<<<<<<<<<<<<< + * if move.piece_id == piece_id + * ]) +*/ + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_8genexpr6__pyx_v_idx))) __PYX_ERR(0, 433, __pyx_L9_error) + + /* "blokus_gym/core/blokus_cython.pyx":435 + * self._actions_by_piece.append([ + * idx for idx, move in enumerate(self._action_moves) + * if move.piece_id == piece_id # <<<<<<<<<<<<<< + * ]) + * +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":434 + * for piece_id in range(self.piece_set.num_pieces): + * self._actions_by_piece.append([ + * idx for idx, move in enumerate(self._action_moves) # <<<<<<<<<<<<<< + * if move.piece_id == piece_id + * ]) +*/ + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_8genexpr6__pyx_v_idx); __pyx_8genexpr6__pyx_v_idx = 0; + __Pyx_XDECREF(__pyx_8genexpr6__pyx_v_move); __pyx_8genexpr6__pyx_v_move = 0; + goto __pyx_L14_exit_scope; + __pyx_L9_error:; + __Pyx_XDECREF(__pyx_8genexpr6__pyx_v_idx); __pyx_8genexpr6__pyx_v_idx = 0; + __Pyx_XDECREF(__pyx_8genexpr6__pyx_v_move); __pyx_8genexpr6__pyx_v_move = 0; + goto __pyx_L1_error; + __pyx_L14_exit_scope:; + } /* exit inner scope */ + + /* "blokus_gym/core/blokus_cython.pyx":433 + * self._actions_by_piece = [] + * for piece_id in range(self.piece_set.num_pieces): + * self._actions_by_piece.append([ # <<<<<<<<<<<<<< + * idx for idx, move in enumerate(self._action_moves) + * if move.piece_id == piece_id +*/ + __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_self->_actions_by_piece, __pyx_t_1); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 433, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":432 + * # Pre-compute action indices per piece + * self._actions_by_piece = [] + * for piece_id in range(self.piece_set.num_pieces): # <<<<<<<<<<<<<< + * self._actions_by_piece.append([ + * idx for idx, move in enumerate(self._action_moves) +*/ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":439 + * + * # Starting corners + * max_idx = board_size - 1 # <<<<<<<<<<<<<< + * self._starting_corners = [ + * (0, 0), +*/ + __pyx_v_max_idx = (__pyx_v_board_size - 1); + + /* "blokus_gym/core/blokus_cython.pyx":442 + * self._starting_corners = [ + * (0, 0), + * (0, max_idx), # <<<<<<<<<<<<<< + * (max_idx, 0), + * (max_idx, max_idx), +*/ + __pyx_t_3 = __Pyx_PyLong_From_long(__pyx_v_max_idx); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 442, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 442, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 442, __pyx_L1_error); + __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":443 + * (0, 0), + * (0, max_idx), + * (max_idx, 0), # <<<<<<<<<<<<<< + * (max_idx, max_idx), + * ] +*/ + __pyx_t_3 = __Pyx_PyLong_From_long(__pyx_v_max_idx); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 443, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 443, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 443, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 443, __pyx_L1_error); + __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":444 + * (0, max_idx), + * (max_idx, 0), + * (max_idx, max_idx), # <<<<<<<<<<<<<< + * ] + * if num_players == 2: +*/ + __pyx_t_3 = __Pyx_PyLong_From_long(__pyx_v_max_idx); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 444, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyLong_From_long(__pyx_v_max_idx); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 444, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = PyTuple_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 444, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 444, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_10, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 444, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_7 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":440 + * # Starting corners + * max_idx = board_size - 1 + * self._starting_corners = [ # <<<<<<<<<<<<<< + * (0, 0), + * (0, max_idx), +*/ + __pyx_t_7 = PyList_New(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 440, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_INCREF(__pyx_mstate_global->__pyx_tuple[6]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[6]); + if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 0, __pyx_mstate_global->__pyx_tuple[6]) != (0)) __PYX_ERR(0, 440, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 1, __pyx_t_1) != (0)) __PYX_ERR(0, 440, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 2, __pyx_t_4) != (0)) __PYX_ERR(0, 440, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_10); + if (__Pyx_PyList_SET_ITEM(__pyx_t_7, 3, __pyx_t_10) != (0)) __PYX_ERR(0, 440, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_4 = 0; + __pyx_t_10 = 0; + __Pyx_GIVEREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_v_self->_starting_corners); + __Pyx_DECREF(__pyx_v_self->_starting_corners); + __pyx_v_self->_starting_corners = ((PyObject*)__pyx_t_7); + __pyx_t_7 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":446 + * (max_idx, max_idx), + * ] + * if num_players == 2: # <<<<<<<<<<<<<< + * self._starting_corners = [(0, 0), (max_idx, max_idx)] + * elif num_players == 3: +*/ + switch (__pyx_v_num_players) { + case 2: + + /* "blokus_gym/core/blokus_cython.pyx":447 + * ] + * if num_players == 2: + * self._starting_corners = [(0, 0), (max_idx, max_idx)] # <<<<<<<<<<<<<< + * elif num_players == 3: + * self._starting_corners = [(0, 0), (0, max_idx), (max_idx, 0)] +*/ + __pyx_t_7 = __Pyx_PyLong_From_long(__pyx_v_max_idx); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 447, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = __Pyx_PyLong_From_long(__pyx_v_max_idx); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 447, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 447, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 447, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_10); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_10) != (0)) __PYX_ERR(0, 447, __pyx_L1_error); + __pyx_t_7 = 0; + __pyx_t_10 = 0; + __pyx_t_10 = PyList_New(2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 447, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_INCREF(__pyx_mstate_global->__pyx_tuple[6]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[6]); + if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 0, __pyx_mstate_global->__pyx_tuple[6]) != (0)) __PYX_ERR(0, 447, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 447, __pyx_L1_error); + __pyx_t_4 = 0; + __Pyx_GIVEREF(__pyx_t_10); + __Pyx_GOTREF(__pyx_v_self->_starting_corners); + __Pyx_DECREF(__pyx_v_self->_starting_corners); + __pyx_v_self->_starting_corners = ((PyObject*)__pyx_t_10); + __pyx_t_10 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":446 + * (max_idx, max_idx), + * ] + * if num_players == 2: # <<<<<<<<<<<<<< + * self._starting_corners = [(0, 0), (max_idx, max_idx)] + * elif num_players == 3: +*/ + break; + case 3: + + /* "blokus_gym/core/blokus_cython.pyx":449 + * self._starting_corners = [(0, 0), (max_idx, max_idx)] + * elif num_players == 3: + * self._starting_corners = [(0, 0), (0, max_idx), (max_idx, 0)] # <<<<<<<<<<<<<< + * + * # Initialize players +*/ + __pyx_t_10 = __Pyx_PyLong_From_long(__pyx_v_max_idx); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 449, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_10); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_10) != (0)) __PYX_ERR(0, 449, __pyx_L1_error); + __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_PyLong_From_long(__pyx_v_max_idx); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_10); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_10) != (0)) __PYX_ERR(0, 449, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 449, __pyx_L1_error); + __pyx_t_10 = 0; + __pyx_t_10 = PyList_New(3); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 449, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_INCREF(__pyx_mstate_global->__pyx_tuple[6]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[6]); + if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 0, __pyx_mstate_global->__pyx_tuple[6]) != (0)) __PYX_ERR(0, 449, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 449, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyList_SET_ITEM(__pyx_t_10, 2, __pyx_t_7) != (0)) __PYX_ERR(0, 449, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_7 = 0; + __Pyx_GIVEREF(__pyx_t_10); + __Pyx_GOTREF(__pyx_v_self->_starting_corners); + __Pyx_DECREF(__pyx_v_self->_starting_corners); + __pyx_v_self->_starting_corners = ((PyObject*)__pyx_t_10); + __pyx_t_10 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":448 + * if num_players == 2: + * self._starting_corners = [(0, 0), (max_idx, max_idx)] + * elif num_players == 3: # <<<<<<<<<<<<<< + * self._starting_corners = [(0, 0), (0, max_idx), (max_idx, 0)] + * +*/ + break; + default: break; + } + + /* "blokus_gym/core/blokus_cython.pyx":452 + * + * # Initialize players + * for i in range(self.num_players): # <<<<<<<<<<<<<< + * player = PlayerState() + * player.idx = i +*/ + __pyx_t_12 = __pyx_v_self->num_players; + __pyx_t_13 = __pyx_t_12; + for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { + __pyx_v_i = __pyx_t_14; + + /* "blokus_gym/core/blokus_cython.pyx":453 + * # Initialize players + * for i in range(self.num_players): + * player = PlayerState() # <<<<<<<<<<<<<< + * player.idx = i + * player.available_pieces = set(self.piece_set.piece_names) +*/ + __pyx_t_7 = NULL; + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL}; + __pyx_t_10 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 453, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_10); + } + __Pyx_XDECREF_SET(__pyx_v_player, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_t_10)); + __pyx_t_10 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":454 + * for i in range(self.num_players): + * player = PlayerState() + * player.idx = i # <<<<<<<<<<<<<< + * player.available_pieces = set(self.piece_set.piece_names) + * if self.corner_rule and i < len(self._starting_corners): +*/ + __pyx_v_player->idx = __pyx_v_i; + + /* "blokus_gym/core/blokus_cython.pyx":455 + * player = PlayerState() + * player.idx = i + * player.available_pieces = set(self.piece_set.piece_names) # <<<<<<<<<<<<<< + * if self.corner_rule and i < len(self._starting_corners): + * player.corners = {self._starting_corners[i]} +*/ + __pyx_t_10 = PySet_New(__pyx_v_self->piece_set->piece_names); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 455, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_GIVEREF(__pyx_t_10); + __Pyx_GOTREF(__pyx_v_player->available_pieces); + __Pyx_DECREF(__pyx_v_player->available_pieces); + __pyx_v_player->available_pieces = ((PyObject*)__pyx_t_10); + __pyx_t_10 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":456 + * player.idx = i + * player.available_pieces = set(self.piece_set.piece_names) + * if self.corner_rule and i < len(self._starting_corners): # <<<<<<<<<<<<<< + * player.corners = {self._starting_corners[i]} + * else: +*/ + if (__pyx_v_self->corner_rule) { + } else { + __pyx_t_2 = __pyx_v_self->corner_rule; + goto __pyx_L19_bool_binop_done; + } + __pyx_t_10 = __pyx_v_self->_starting_corners; + __Pyx_INCREF(__pyx_t_10); + if (unlikely(__pyx_t_10 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(0, 456, __pyx_L1_error) + } + __pyx_t_8 = __Pyx_PyList_GET_SIZE(__pyx_t_10); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(0, 456, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_15 = (__pyx_v_i < __pyx_t_8); + __pyx_t_2 = __pyx_t_15; + __pyx_L19_bool_binop_done:; + if (__pyx_t_2) { + + /* "blokus_gym/core/blokus_cython.pyx":457 + * player.available_pieces = set(self.piece_set.piece_names) + * if self.corner_rule and i < len(self._starting_corners): + * player.corners = {self._starting_corners[i]} # <<<<<<<<<<<<<< + * else: + * player.corners = set() +*/ + if (unlikely(__pyx_v_self->_starting_corners == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 457, __pyx_L1_error) + } + __pyx_t_10 = __Pyx_GetItemInt_List(__pyx_v_self->_starting_corners, __pyx_v_i, int, 1, __Pyx_PyLong_From_int, 1, 1, 1, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 457, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_7 = PySet_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 457, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (PySet_Add(__pyx_t_7, __pyx_t_10) < (0)) __PYX_ERR(0, 457, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_GIVEREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_v_player->corners); + __Pyx_DECREF(__pyx_v_player->corners); + __pyx_v_player->corners = ((PyObject*)__pyx_t_7); + __pyx_t_7 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":456 + * player.idx = i + * player.available_pieces = set(self.piece_set.piece_names) + * if self.corner_rule and i < len(self._starting_corners): # <<<<<<<<<<<<<< + * player.corners = {self._starting_corners[i]} + * else: +*/ + goto __pyx_L18; + } + + /* "blokus_gym/core/blokus_cython.pyx":459 + * player.corners = {self._starting_corners[i]} + * else: + * player.corners = set() # <<<<<<<<<<<<<< + * player.score = 0 + * player.has_started = False +*/ + /*else*/ { + __pyx_t_7 = PySet_New(0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 459, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + __Pyx_GOTREF(__pyx_v_player->corners); + __Pyx_DECREF(__pyx_v_player->corners); + __pyx_v_player->corners = ((PyObject*)__pyx_t_7); + __pyx_t_7 = 0; + } + __pyx_L18:; + + /* "blokus_gym/core/blokus_cython.pyx":460 + * else: + * player.corners = set() + * player.score = 0 # <<<<<<<<<<<<<< + * player.has_started = False + * player.can_move = True +*/ + __pyx_v_player->score = 0; + + /* "blokus_gym/core/blokus_cython.pyx":461 + * player.corners = set() + * player.score = 0 + * player.has_started = False # <<<<<<<<<<<<<< + * player.can_move = True + * self.players.append(player) +*/ + __pyx_v_player->has_started = 0; + + /* "blokus_gym/core/blokus_cython.pyx":462 + * player.score = 0 + * player.has_started = False + * player.can_move = True # <<<<<<<<<<<<<< + * self.players.append(player) + * +*/ + __pyx_v_player->can_move = 1; + + /* "blokus_gym/core/blokus_cython.pyx":463 + * player.has_started = False + * player.can_move = True + * self.players.append(player) # <<<<<<<<<<<<<< + * + * cdef void _generate_action_space(self): +*/ + if (unlikely(__pyx_v_self->players == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append"); + __PYX_ERR(0, 463, __pyx_L1_error) + } + __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_self->players, ((PyObject *)__pyx_v_player)); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 463, __pyx_L1_error) + } + + /* "blokus_gym/core/blokus_cython.pyx":413 + * cdef public list _starting_corners + * + * def __init__(self, int board_size=20, PieceSet pieces=None, int num_players=4, bint corner_rule=True): # <<<<<<<<<<<<<< + * self.board_size = board_size + * self.piece_set = pieces or PieceSet(STANDARD_PIECES) +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_piece_id); + __Pyx_XDECREF((PyObject *)__pyx_v_player); + __Pyx_XDECREF(__pyx_8genexpr6__pyx_v_idx); + __Pyx_XDECREF(__pyx_8genexpr6__pyx_v_move); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_10BlokusGame_22_generate_action_space_2generator3(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ + +/* "blokus_gym/core/blokus_cython.pyx":481 + * for orient_id, orient in enumerate(self.piece_set.get_orientations(piece_id)): + * squares = orient.squares + * max_x = max(x for x, _ in squares) # <<<<<<<<<<<<<< + * max_y = max(y for _, y in squares) + * +*/ + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_22_generate_action_space_genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 481, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_10blokus_gym_4core_13blokus_cython_10BlokusGame_22_generate_action_space_2generator3, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_BlokusGame__generate_action_spac, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython); if (unlikely(!gen)) __PYX_ERR(0, 481, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame._generate_action_space.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF((PyObject *)__pyx_cur_scope); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_10BlokusGame_22_generate_action_space_2generator3(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr *__pyx_cur_scope = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __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)(PyObject *); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L8_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(__pyx_sent_value != Py_None)) { + if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started generator"); + __PYX_ERR(0, 481, __pyx_L1_error) + } + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 481, __pyx_L1_error) } + if (unlikely(__pyx_cur_scope->__pyx_genexpr_arg_0 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 481, __pyx_L1_error) + } + __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 481, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + __pyx_t_3 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_1, __pyx_t_2, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + 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(0, 481, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_5); + } else { + __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 481, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 481, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_5); + } + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); + index = 0; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < (0)) __PYX_ERR(0, 481, __pyx_L1_error) + __pyx_t_7 = NULL; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L7_unpacking_done; + __pyx_L6_unpacking_failed:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 481, __pyx_L1_error) + __pyx_L7_unpacking_done:; + } + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_x); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_x, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v__); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v__, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_5); + __pyx_t_5 = 0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_x); + __pyx_r = __pyx_cur_scope->__pyx_v_x; + __Pyx_XGIVEREF(__pyx_t_1); + __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; + __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L8_resume_from_yield:; + __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; + __pyx_cur_scope->__pyx_t_0 = 0; + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 481, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + if (__Pyx_PyErr_Occurred()) { + __Pyx_Generator_Replace_StopIteration(0); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_10BlokusGame_22_generate_action_space_5generator4(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ + +/* "blokus_gym/core/blokus_cython.pyx":482 + * squares = orient.squares + * max_x = max(x for x, _ in squares) + * max_y = max(y for _, y in squares) # <<<<<<<<<<<<<< + * + * for px in range(self.board_size - max_x): +*/ + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_22_generate_action_space_3genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 482, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_10blokus_gym_4core_13blokus_cython_10BlokusGame_22_generate_action_space_5generator4, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_BlokusGame__generate_action_spac, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython); if (unlikely(!gen)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame._generate_action_space.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF((PyObject *)__pyx_cur_scope); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_10BlokusGame_22_generate_action_space_5generator4(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr *__pyx_cur_scope = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __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)(PyObject *); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + case 1: goto __pyx_L8_resume_from_yield; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(__pyx_sent_value != Py_None)) { + if (unlikely(__pyx_sent_value)) PyErr_SetString(PyExc_TypeError, "can't send non-None value to a just-started generator"); + __PYX_ERR(0, 482, __pyx_L1_error) + } + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 482, __pyx_L1_error) } + if (unlikely(__pyx_cur_scope->__pyx_genexpr_arg_0 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 482, __pyx_L1_error) + } + __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 482, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + __pyx_t_3 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_1, __pyx_t_2, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + 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(0, 482, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_5); + } else { + __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_5); + } + #else + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_6 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_6); + index = 0; __pyx_t_4 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_4)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + index = 1; __pyx_t_5 = __pyx_t_7(__pyx_t_6); if (unlikely(!__pyx_t_5)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_7(__pyx_t_6), 2) < (0)) __PYX_ERR(0, 482, __pyx_L1_error) + __pyx_t_7 = NULL; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + goto __pyx_L7_unpacking_done; + __pyx_L6_unpacking_failed:; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 482, __pyx_L1_error) + __pyx_L7_unpacking_done:; + } + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v__); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v__, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_y); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_y, __pyx_t_5); + __Pyx_GIVEREF(__pyx_t_5); + __pyx_t_5 = 0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_v_y); + __pyx_r = __pyx_cur_scope->__pyx_v_y; + __Pyx_XGIVEREF(__pyx_t_1); + __pyx_cur_scope->__pyx_t_0 = __pyx_t_1; + __pyx_cur_scope->__pyx_t_1 = __pyx_t_2; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + /* return from generator, yielding value */ + __pyx_generator->resume_label = 1; + return __pyx_r; + __pyx_L8_resume_from_yield:; + __pyx_t_1 = __pyx_cur_scope->__pyx_t_0; + __pyx_cur_scope->__pyx_t_0 = 0; + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_2 = __pyx_cur_scope->__pyx_t_1; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 482, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + if (__Pyx_PyErr_Occurred()) { + __Pyx_Generator_Replace_StopIteration(0); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":465 + * self.players.append(player) + * + * cdef void _generate_action_space(self): # <<<<<<<<<<<<<< + * """Pre-compute all possible (piece, orientation, position) moves.""" + * cdef int piece_id, orient_id +*/ + +static void __pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame__generate_action_space(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + int __pyx_v_piece_id; + int __pyx_v_orient_id; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_orient = 0; + PyObject *__pyx_v_squares = 0; + int __pyx_v_max_x; + int __pyx_v_max_y; + int __pyx_v_px; + int __pyx_v_py; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_move = 0; + int __pyx_v_action_idx; + PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_10BlokusGame_22_generate_action_space_2generator3 = 0; + PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_10BlokusGame_22_generate_action_space_5generator4 = 0; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __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; + size_t __pyx_t_8; + Py_ssize_t __pyx_t_9; + PyObject *(*__pyx_t_10)(PyObject *); + PyObject *__pyx_t_11 = NULL; + int __pyx_t_12; + int __pyx_t_13; + int __pyx_t_14; + int __pyx_t_15; + int __pyx_t_16; + int __pyx_t_17; + PyObject *__pyx_t_18 = NULL; + PyObject *__pyx_t_19 = NULL; + PyObject *__pyx_t_20 = NULL; + Py_ssize_t __pyx_t_21; + int __pyx_t_22; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_generate_action_space", 0); + + /* "blokus_gym/core/blokus_cython.pyx":475 + * cdef int action_idx + * + * self._action_moves = [] # <<<<<<<<<<<<<< + * self._move_to_action = {} + * +*/ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 475, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_action_moves); + __Pyx_DECREF(__pyx_v_self->_action_moves); + __pyx_v_self->_action_moves = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":476 + * + * self._action_moves = [] + * self._move_to_action = {} # <<<<<<<<<<<<<< + * + * for piece_id in range(self.piece_set.num_pieces): +*/ + __pyx_t_1 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 476, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_move_to_action); + __Pyx_DECREF(__pyx_v_self->_move_to_action); + __pyx_v_self->_move_to_action = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":478 + * self._move_to_action = {} + * + * for piece_id in range(self.piece_set.num_pieces): # <<<<<<<<<<<<<< + * for orient_id, orient in enumerate(self.piece_set.get_orientations(piece_id)): + * squares = orient.squares +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self->piece_set), __pyx_mstate_global->__pyx_n_u_num_pieces); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyIndex_AsSsize_t(__pyx_t_1); if (unlikely((__pyx_t_2 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(0, 478, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_piece_id = __pyx_t_4; + + /* "blokus_gym/core/blokus_cython.pyx":479 + * + * for piece_id in range(self.piece_set.num_pieces): + * for orient_id, orient in enumerate(self.piece_set.get_orientations(piece_id)): # <<<<<<<<<<<<<< + * squares = orient.squares + * max_x = max(x for x, _ in squares) +*/ + __pyx_t_5 = 0; + __pyx_t_6 = ((PyObject *)__pyx_v_self->piece_set); + __Pyx_INCREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_piece_id); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_7}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get_orientations, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (likely(PyList_CheckExact(__pyx_t_1)) || PyTuple_CheckExact(__pyx_t_1)) { + __pyx_t_7 = __pyx_t_1; __Pyx_INCREF(__pyx_t_7); + __pyx_t_9 = 0; + __pyx_t_10 = NULL; + } else { + __pyx_t_9 = -1; __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_10 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 479, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + if (likely(!__pyx_t_10)) { + if (likely(PyList_CheckExact(__pyx_t_7))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 479, __pyx_L1_error) + #endif + if (__pyx_t_9 >= __pyx_temp) break; + } + __pyx_t_1 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_7, __pyx_t_9, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_9; + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_7); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 479, __pyx_L1_error) + #endif + if (__pyx_t_9 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_7, __pyx_t_9)); + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(__pyx_t_7, __pyx_t_9); + #endif + ++__pyx_t_9; + } + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 479, __pyx_L1_error) + } else { + __pyx_t_1 = __pyx_t_10(__pyx_t_7); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 479, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation))))) __PYX_ERR(0, 479, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_orient, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)__pyx_t_1)); + __pyx_t_1 = 0; + __pyx_v_orient_id = __pyx_t_5; + __pyx_t_5 = (__pyx_t_5 + 1); + + /* "blokus_gym/core/blokus_cython.pyx":480 + * for piece_id in range(self.piece_set.num_pieces): + * for orient_id, orient in enumerate(self.piece_set.get_orientations(piece_id)): + * squares = orient.squares # <<<<<<<<<<<<<< + * max_x = max(x for x, _ in squares) + * max_y = max(y for _, y in squares) +*/ + __pyx_t_1 = __pyx_v_orient->squares; + __Pyx_INCREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_squares, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":481 + * for orient_id, orient in enumerate(self.piece_set.get_orientations(piece_id)): + * squares = orient.squares + * max_x = max(x for x, _ in squares) # <<<<<<<<<<<<<< + * max_y = max(y for _, y in squares) + * +*/ + __pyx_t_6 = NULL; + __pyx_t_11 = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_22_generate_action_space_genexpr(NULL, __pyx_v_squares); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_8 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_11}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_max, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_12 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 481, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_max_x = __pyx_t_12; + + /* "blokus_gym/core/blokus_cython.pyx":482 + * squares = orient.squares + * max_x = max(x for x, _ in squares) + * max_y = max(y for _, y in squares) # <<<<<<<<<<<<<< + * + * for px in range(self.board_size - max_x): +*/ + __pyx_t_11 = NULL; + __pyx_t_6 = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_22_generate_action_space_3genexpr(NULL, __pyx_v_squares); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin_max, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_12 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 482, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_max_y = __pyx_t_12; + + /* "blokus_gym/core/blokus_cython.pyx":484 + * max_y = max(y for _, y in squares) + * + * for px in range(self.board_size - max_x): # <<<<<<<<<<<<<< + * for py in range(self.board_size - max_y): + * move = Move(piece_id, orient_id, px, py) +*/ + __pyx_t_12 = (__pyx_v_self->board_size - __pyx_v_max_x); + __pyx_t_13 = __pyx_t_12; + for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { + __pyx_v_px = __pyx_t_14; + + /* "blokus_gym/core/blokus_cython.pyx":485 + * + * for px in range(self.board_size - max_x): + * for py in range(self.board_size - max_y): # <<<<<<<<<<<<<< + * move = Move(piece_id, orient_id, px, py) + * action_idx = len(self._action_moves) +*/ + __pyx_t_15 = (__pyx_v_self->board_size - __pyx_v_max_y); + __pyx_t_16 = __pyx_t_15; + for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { + __pyx_v_py = __pyx_t_17; + + /* "blokus_gym/core/blokus_cython.pyx":486 + * for px in range(self.board_size - max_x): + * for py in range(self.board_size - max_y): + * move = Move(piece_id, orient_id, px, py) # <<<<<<<<<<<<<< + * action_idx = len(self._action_moves) + * self._action_moves.append(move) +*/ + __pyx_t_6 = NULL; + __pyx_t_11 = __Pyx_PyLong_From_int(__pyx_v_piece_id); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_18 = __Pyx_PyLong_From_int(__pyx_v_orient_id); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __pyx_t_19 = __Pyx_PyLong_From_int(__pyx_v_px); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __pyx_t_20 = __Pyx_PyLong_From_int(__pyx_v_py); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 486, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_20); + __pyx_t_8 = 1; + { + PyObject *__pyx_callargs[5] = {__pyx_t_6, __pyx_t_11, __pyx_t_18, __pyx_t_19, __pyx_t_20}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move, __pyx_callargs+__pyx_t_8, (5-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_DECREF(__pyx_t_20); __pyx_t_20 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 486, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + } + __Pyx_XDECREF_SET(__pyx_v_move, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":487 + * for py in range(self.board_size - max_y): + * move = Move(piece_id, orient_id, px, py) + * action_idx = len(self._action_moves) # <<<<<<<<<<<<<< + * self._action_moves.append(move) + * self._move_to_action[(piece_id, orient_id, px, py)] = action_idx +*/ + __pyx_t_1 = __pyx_v_self->_action_moves; + __Pyx_INCREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(0, 487, __pyx_L1_error) + } + __pyx_t_21 = __Pyx_PyList_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_21 == ((Py_ssize_t)-1))) __PYX_ERR(0, 487, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_action_idx = __pyx_t_21; + + /* "blokus_gym/core/blokus_cython.pyx":488 + * move = Move(piece_id, orient_id, px, py) + * action_idx = len(self._action_moves) + * self._action_moves.append(move) # <<<<<<<<<<<<<< + * self._move_to_action[(piece_id, orient_id, px, py)] = action_idx + * +*/ + if (unlikely(__pyx_v_self->_action_moves == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append"); + __PYX_ERR(0, 488, __pyx_L1_error) + } + __pyx_t_22 = __Pyx_PyList_Append(__pyx_v_self->_action_moves, ((PyObject *)__pyx_v_move)); if (unlikely(__pyx_t_22 == ((int)-1))) __PYX_ERR(0, 488, __pyx_L1_error) + + /* "blokus_gym/core/blokus_cython.pyx":489 + * action_idx = len(self._action_moves) + * self._action_moves.append(move) + * self._move_to_action[(piece_id, orient_id, px, py)] = action_idx # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_action_idx); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely(__pyx_v_self->_move_to_action == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 489, __pyx_L1_error) + } + __pyx_t_20 = __Pyx_PyLong_From_int(__pyx_v_piece_id); if (unlikely(!__pyx_t_20)) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_20); + __pyx_t_19 = __Pyx_PyLong_From_int(__pyx_v_orient_id); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __pyx_t_18 = __Pyx_PyLong_From_int(__pyx_v_px); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __pyx_t_11 = __Pyx_PyLong_From_int(__pyx_v_py); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_6 = PyTuple_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_20); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_20) != (0)) __PYX_ERR(0, 489, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_19); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_19) != (0)) __PYX_ERR(0, 489, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_18); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_18) != (0)) __PYX_ERR(0, 489, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_11); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 3, __pyx_t_11) != (0)) __PYX_ERR(0, 489, __pyx_L1_error); + __pyx_t_20 = 0; + __pyx_t_19 = 0; + __pyx_t_18 = 0; + __pyx_t_11 = 0; + if (unlikely((PyDict_SetItem(__pyx_v_self->_move_to_action, __pyx_t_6, __pyx_t_1) < 0))) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + } + + /* "blokus_gym/core/blokus_cython.pyx":479 + * + * for piece_id in range(self.piece_set.num_pieces): + * for orient_id, orient in enumerate(self.piece_set.get_orientations(piece_id)): # <<<<<<<<<<<<<< + * squares = orient.squares + * max_x = max(x for x, _ in squares) +*/ + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + + /* "blokus_gym/core/blokus_cython.pyx":465 + * self.players.append(player) + * + * cdef void _generate_action_space(self): # <<<<<<<<<<<<<< + * """Pre-compute all possible (piece, orientation, position) moves.""" + * cdef int piece_id, orient_id +*/ + + /* function exit code */ + 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_11); + __Pyx_XDECREF(__pyx_t_18); + __Pyx_XDECREF(__pyx_t_19); + __Pyx_XDECREF(__pyx_t_20); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame._generate_action_space", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_orient); + __Pyx_XDECREF(__pyx_v_squares); + __Pyx_XDECREF((PyObject *)__pyx_v_move); + __Pyx_XDECREF(__pyx_gb_10blokus_gym_4core_13blokus_cython_10BlokusGame_22_generate_action_space_2generator3); + __Pyx_XDECREF(__pyx_gb_10blokus_gym_4core_13blokus_cython_10BlokusGame_22_generate_action_space_5generator4); + __Pyx_RefNannyFinishContext(); +} + +/* "blokus_gym/core/blokus_cython.pyx":491 + * self._move_to_action[(piece_id, orient_id, px, py)] = action_idx + * + * @property # <<<<<<<<<<<<<< + * def num_actions(self) -> int: + * return len(self._action_moves) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_11num_actions_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_11num_actions_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_11num_actions___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_11num_actions___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "blokus_gym/core/blokus_cython.pyx":493 + * @property + * def num_actions(self) -> int: + * return len(self._action_moves) # <<<<<<<<<<<<<< + * + * def get_move(self, int action) -> Move: +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_v_self->_action_moves; + __Pyx_INCREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(0, 493, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyList_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_2 == ((Py_ssize_t)-1))) __PYX_ERR(0, 493, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyLong_FromSsize_t(__pyx_t_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":491 + * self._move_to_action[(piece_id, orient_id, px, py)] = action_idx + * + * @property # <<<<<<<<<<<<<< + * def num_actions(self) -> int: + * return len(self._action_moves) +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.num_actions.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":495 + * return len(self._action_moves) + * + * def get_move(self, int action) -> Move: # <<<<<<<<<<<<<< + * return self._action_moves[action] + * +*/ + +/* Python wrapper */ +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_3get_move(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_3get_move = {"get_move", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_3get_move, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_3get_move(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + int __pyx_v_action; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_move (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_action,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 495, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 495, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_move", 0) < (0)) __PYX_ERR(0, 495, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_move", 1, 1, 1, i); __PYX_ERR(0, 495, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 495, __pyx_L3_error) + } + __pyx_v_action = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_action == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 495, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_move", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 495, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.get_move", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_2get_move(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), __pyx_v_action); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_2get_move(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, int __pyx_v_action) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__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_move", 0); + + /* "blokus_gym/core/blokus_cython.pyx":496 + * + * def get_move(self, int action) -> Move: + * return self._action_moves[action] # <<<<<<<<<<<<<< + * + * def get_action(self, Move move) -> int: +*/ + __Pyx_XDECREF((PyObject *)__pyx_r); + if (unlikely(__pyx_v_self->_action_moves == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 496, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_self->_action_moves, __pyx_v_action, int, 1, __Pyx_PyLong_From_int, 1, 1, 1, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move))))) __PYX_ERR(0, 496, __pyx_L1_error) + __pyx_r = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":495 + * return len(self._action_moves) + * + * def get_move(self, int action) -> Move: # <<<<<<<<<<<<<< + * return self._action_moves[action] + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.get_move", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":498 + * return self._action_moves[action] + * + * def get_action(self, Move move) -> int: # <<<<<<<<<<<<<< + * return self._move_to_action[(move.piece_id, move.orientation_id, move.x, move.y)] + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_5get_action(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_5get_action = {"get_action", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_5get_action, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_5get_action(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_move = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_action (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_move,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 498, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 498, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_action", 0) < (0)) __PYX_ERR(0, 498, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_action", 1, 1, 1, i); __PYX_ERR(0, 498, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 498, __pyx_L3_error) + } + __pyx_v_move = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)values[0]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_action", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 498, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.get_action", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_move), __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move, 1, "move", 0))) __PYX_ERR(0, 498, __pyx_L1_error) + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_4get_action(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), __pyx_v_move); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_4get_action(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_move) { + 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; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_action", 0); + + /* "blokus_gym/core/blokus_cython.pyx":499 + * + * def get_action(self, Move move) -> int: + * return self._move_to_action[(move.piece_id, move.orientation_id, move.x, move.y)] # <<<<<<<<<<<<<< + * + * def reset(self) -> None: +*/ + __Pyx_XDECREF(__pyx_r); + if (unlikely(__pyx_v_self->_move_to_action == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 499, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_move->piece_id); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_move->orientation_id); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_move->x); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_move->y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 499, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 499, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 499, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 499, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_GetItem(__pyx_v_self->_move_to_action, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 499, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__Pyx_PyInt_FromNumber(&__pyx_t_4, NULL, 1) < (0)) __PYX_ERR(0, 499, __pyx_L1_error) + __pyx_r = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":498 + * return self._action_moves[action] + * + * def get_action(self, Move move) -> int: # <<<<<<<<<<<<<< + * return self._move_to_action[(move.piece_id, move.orientation_id, move.x, move.y)] + * +*/ + + /* 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_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.get_action", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":501 + * return self._move_to_action[(move.piece_id, move.orientation_id, move.x, move.y)] + * + * def reset(self) -> None: # <<<<<<<<<<<<<< + * """Reset the game to its initial state.""" + * self.board = Board(self.board_size) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_7reset(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_6reset, "Reset the game to its initial state."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_7reset = {"reset", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_7reset, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_6reset}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_7reset(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("reset (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("reset", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("reset", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_6reset(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_6reset(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + int __pyx_v_i; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_player = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + int __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("reset", 0); + + /* "blokus_gym/core/blokus_cython.pyx":503 + * def reset(self) -> None: + * """Reset the game to its initial state.""" + * self.board = Board(self.board_size) # <<<<<<<<<<<<<< + * self.players = [] + * self.current_player = 0 +*/ + __pyx_t_2 = NULL; + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_self->board_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 503, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 503, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + } + __Pyx_GIVEREF((PyObject *)__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->board); + __Pyx_DECREF(__pyx_v_self->board); + __pyx_v_self->board = ((PyObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":504 + * """Reset the game to its initial state.""" + * self.board = Board(self.board_size) + * self.players = [] # <<<<<<<<<<<<<< + * self.current_player = 0 + * self.rounds = 0 +*/ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 504, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->players); + __Pyx_DECREF(__pyx_v_self->players); + __pyx_v_self->players = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":505 + * self.board = Board(self.board_size) + * self.players = [] + * self.current_player = 0 # <<<<<<<<<<<<<< + * self.rounds = 0 + * self.game_over = False +*/ + __pyx_v_self->current_player = 0; + + /* "blokus_gym/core/blokus_cython.pyx":506 + * self.players = [] + * self.current_player = 0 + * self.rounds = 0 # <<<<<<<<<<<<<< + * self.game_over = False + * +*/ + __pyx_v_self->rounds = 0; + + /* "blokus_gym/core/blokus_cython.pyx":507 + * self.current_player = 0 + * self.rounds = 0 + * self.game_over = False # <<<<<<<<<<<<<< + * + * for i in range(self.num_players): +*/ + __pyx_v_self->game_over = 0; + + /* "blokus_gym/core/blokus_cython.pyx":509 + * self.game_over = False + * + * for i in range(self.num_players): # <<<<<<<<<<<<<< + * player = PlayerState() + * player.idx = i +*/ + __pyx_t_5 = __pyx_v_self->num_players; + __pyx_t_6 = __pyx_t_5; + for (__pyx_t_7 = 0; __pyx_t_7 < __pyx_t_6; __pyx_t_7+=1) { + __pyx_v_i = __pyx_t_7; + + /* "blokus_gym/core/blokus_cython.pyx":510 + * + * for i in range(self.num_players): + * player = PlayerState() # <<<<<<<<<<<<<< + * player.idx = i + * player.available_pieces = set(self.piece_set.piece_names) +*/ + __pyx_t_3 = NULL; + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 510, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + } + __Pyx_XDECREF_SET(__pyx_v_player, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":511 + * for i in range(self.num_players): + * player = PlayerState() + * player.idx = i # <<<<<<<<<<<<<< + * player.available_pieces = set(self.piece_set.piece_names) + * if self.corner_rule and i < len(self._starting_corners): +*/ + __pyx_v_player->idx = __pyx_v_i; + + /* "blokus_gym/core/blokus_cython.pyx":512 + * player = PlayerState() + * player.idx = i + * player.available_pieces = set(self.piece_set.piece_names) # <<<<<<<<<<<<<< + * if self.corner_rule and i < len(self._starting_corners): + * player.corners = {self._starting_corners[i]} +*/ + __pyx_t_1 = PySet_New(__pyx_v_self->piece_set->piece_names); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 512, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_player->available_pieces); + __Pyx_DECREF(__pyx_v_player->available_pieces); + __pyx_v_player->available_pieces = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":513 + * player.idx = i + * player.available_pieces = set(self.piece_set.piece_names) + * if self.corner_rule and i < len(self._starting_corners): # <<<<<<<<<<<<<< + * player.corners = {self._starting_corners[i]} + * else: +*/ + if (__pyx_v_self->corner_rule) { + } else { + __pyx_t_8 = __pyx_v_self->corner_rule; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_1 = __pyx_v_self->_starting_corners; + __Pyx_INCREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(0, 513, __pyx_L1_error) + } + __pyx_t_9 = __Pyx_PyList_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_9 == ((Py_ssize_t)-1))) __PYX_ERR(0, 513, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_10 = (__pyx_v_i < __pyx_t_9); + __pyx_t_8 = __pyx_t_10; + __pyx_L6_bool_binop_done:; + if (__pyx_t_8) { + + /* "blokus_gym/core/blokus_cython.pyx":514 + * player.available_pieces = set(self.piece_set.piece_names) + * if self.corner_rule and i < len(self._starting_corners): + * player.corners = {self._starting_corners[i]} # <<<<<<<<<<<<<< + * else: + * player.corners = set() +*/ + if (unlikely(__pyx_v_self->_starting_corners == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 514, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_self->_starting_corners, __pyx_v_i, int, 1, __Pyx_PyLong_From_int, 1, 1, 1, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PySet_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PySet_Add(__pyx_t_3, __pyx_t_1) < (0)) __PYX_ERR(0, 514, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_player->corners); + __Pyx_DECREF(__pyx_v_player->corners); + __pyx_v_player->corners = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":513 + * player.idx = i + * player.available_pieces = set(self.piece_set.piece_names) + * if self.corner_rule and i < len(self._starting_corners): # <<<<<<<<<<<<<< + * player.corners = {self._starting_corners[i]} + * else: +*/ + goto __pyx_L5; + } + + /* "blokus_gym/core/blokus_cython.pyx":516 + * player.corners = {self._starting_corners[i]} + * else: + * player.corners = set() # <<<<<<<<<<<<<< + * player.score = 0 + * player.has_started = False +*/ + /*else*/ { + __pyx_t_3 = PySet_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 516, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_player->corners); + __Pyx_DECREF(__pyx_v_player->corners); + __pyx_v_player->corners = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + } + __pyx_L5:; + + /* "blokus_gym/core/blokus_cython.pyx":517 + * else: + * player.corners = set() + * player.score = 0 # <<<<<<<<<<<<<< + * player.has_started = False + * player.can_move = True +*/ + __pyx_v_player->score = 0; + + /* "blokus_gym/core/blokus_cython.pyx":518 + * player.corners = set() + * player.score = 0 + * player.has_started = False # <<<<<<<<<<<<<< + * player.can_move = True + * self.players.append(player) +*/ + __pyx_v_player->has_started = 0; + + /* "blokus_gym/core/blokus_cython.pyx":519 + * player.score = 0 + * player.has_started = False + * player.can_move = True # <<<<<<<<<<<<<< + * self.players.append(player) + * +*/ + __pyx_v_player->can_move = 1; + + /* "blokus_gym/core/blokus_cython.pyx":520 + * player.has_started = False + * player.can_move = True + * self.players.append(player) # <<<<<<<<<<<<<< + * + * cdef list _get_placed_squares(self, Move move): +*/ + if (unlikely(__pyx_v_self->players == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "append"); + __PYX_ERR(0, 520, __pyx_L1_error) + } + __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_self->players, ((PyObject *)__pyx_v_player)); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 520, __pyx_L1_error) + } + + /* "blokus_gym/core/blokus_cython.pyx":501 + * return self._move_to_action[(move.piece_id, move.orientation_id, move.x, move.y)] + * + * def reset(self) -> None: # <<<<<<<<<<<<<< + * """Reset the game to its initial state.""" + * self.board = Board(self.board_size) +*/ + + /* 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_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.reset", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_player); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":522 + * self.players.append(player) + * + * cdef list _get_placed_squares(self, Move move): # <<<<<<<<<<<<<< + * """Get the absolute board coordinates for a move.""" + * cdef PieceOrientation orient = self.piece_set.get_orientations(move.piece_id)[move.orientation_id] +*/ + +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame__get_placed_squares(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_move) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_orient = 0; + PyObject *__pyx_v_result = 0; + int __pyx_v_dx; + int __pyx_v_dy; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *(*__pyx_t_8)(PyObject *); + int __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("_get_placed_squares", 0); + + /* "blokus_gym/core/blokus_cython.pyx":524 + * cdef list _get_placed_squares(self, Move move): + * """Get the absolute board coordinates for a move.""" + * cdef PieceOrientation orient = self.piece_set.get_orientations(move.piece_id)[move.orientation_id] # <<<<<<<<<<<<<< + * cdef list result = [] + * cdef int dx, dy +*/ + __pyx_t_2 = ((PyObject *)__pyx_v_self->piece_set); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_move->piece_id); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 524, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get_orientations, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 524, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_move->orientation_id, int, 1, __Pyx_PyLong_From_int, 0, 1, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 524, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation))))) __PYX_ERR(0, 524, __pyx_L1_error) + __pyx_v_orient = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":525 + * """Get the absolute board coordinates for a move.""" + * cdef PieceOrientation orient = self.piece_set.get_orientations(move.piece_id)[move.orientation_id] + * cdef list result = [] # <<<<<<<<<<<<<< + * cdef int dx, dy + * for dx, dy in orient.squares: +*/ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 525, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_result = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":527 + * cdef list result = [] + * cdef int dx, dy + * for dx, dy in orient.squares: # <<<<<<<<<<<<<< + * result.append((move.x + dx, move.y + dy)) + * return result +*/ + if (unlikely(__pyx_v_orient->squares == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 527, __pyx_L1_error) + } + __pyx_t_3 = __pyx_v_orient->squares; __Pyx_INCREF(__pyx_t_3); + __pyx_t_5 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 527, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) break; + } + __pyx_t_1 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_3, __pyx_t_5, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_5; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 527, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { + PyObject* sequence = __pyx_t_1; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 527, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_6); + } else { + __pyx_t_2 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 527, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 527, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_6); + } + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 527, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 527, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 527, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); + index = 0; __pyx_t_2 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_2)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < (0)) __PYX_ERR(0, 527, __pyx_L1_error) + __pyx_t_8 = NULL; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L6_unpacking_done; + __pyx_L5_unpacking_failed:; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 527, __pyx_L1_error) + __pyx_L6_unpacking_done:; + } + __pyx_t_9 = __Pyx_PyLong_As_int(__pyx_t_2); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 527, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_10 = __Pyx_PyLong_As_int(__pyx_t_6); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 527, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_v_dx = __pyx_t_9; + __pyx_v_dy = __pyx_t_10; + + /* "blokus_gym/core/blokus_cython.pyx":528 + * cdef int dx, dy + * for dx, dy in orient.squares: + * result.append((move.x + dx, move.y + dy)) # <<<<<<<<<<<<<< + * return result + * +*/ + __pyx_t_1 = __Pyx_PyLong_From_int((__pyx_v_move->x + __pyx_v_dx)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 528, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyLong_From_int((__pyx_v_move->y + __pyx_v_dy)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 528, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 528, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 528, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 528, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_6 = 0; + __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_result, __pyx_t_2); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 528, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":527 + * cdef list result = [] + * cdef int dx, dy + * for dx, dy in orient.squares: # <<<<<<<<<<<<<< + * result.append((move.x + dx, move.y + dy)) + * return result +*/ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":529 + * for dx, dy in orient.squares: + * result.append((move.x + dx, move.y + dy)) + * return result # <<<<<<<<<<<<<< + * + * cdef list _get_placed_corners(self, Move move): +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":522 + * self.players.append(player) + * + * cdef list _get_placed_squares(self, Move move): # <<<<<<<<<<<<<< + * """Get the absolute board coordinates for a move.""" + * cdef PieceOrientation orient = self.piece_set.get_orientations(move.piece_id)[move.orientation_id] +*/ + + /* 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_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame._get_placed_squares", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_orient); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":531 + * return result + * + * cdef list _get_placed_corners(self, Move move): # <<<<<<<<<<<<<< + * """Get the absolute corner coordinates for a move.""" + * cdef PieceOrientation orient = self.piece_set.get_orientations(move.piece_id)[move.orientation_id] +*/ + +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame__get_placed_corners(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_move) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v_orient = 0; + PyObject *__pyx_v_result = 0; + int __pyx_v_dx; + int __pyx_v_dy; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *(*__pyx_t_8)(PyObject *); + int __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("_get_placed_corners", 0); + + /* "blokus_gym/core/blokus_cython.pyx":533 + * cdef list _get_placed_corners(self, Move move): + * """Get the absolute corner coordinates for a move.""" + * cdef PieceOrientation orient = self.piece_set.get_orientations(move.piece_id)[move.orientation_id] # <<<<<<<<<<<<<< + * cdef list result = [] + * cdef int dx, dy +*/ + __pyx_t_2 = ((PyObject *)__pyx_v_self->piece_set); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_move->piece_id); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 533, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get_orientations, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 533, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_3 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_move->orientation_id, int, 1, __Pyx_PyLong_From_int, 0, 1, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 533, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation))))) __PYX_ERR(0, 533, __pyx_L1_error) + __pyx_v_orient = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":534 + * """Get the absolute corner coordinates for a move.""" + * cdef PieceOrientation orient = self.piece_set.get_orientations(move.piece_id)[move.orientation_id] + * cdef list result = [] # <<<<<<<<<<<<<< + * cdef int dx, dy + * for dx, dy in orient.corners: +*/ + __pyx_t_3 = PyList_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 534, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_result = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":536 + * cdef list result = [] + * cdef int dx, dy + * for dx, dy in orient.corners: # <<<<<<<<<<<<<< + * result.append((move.x + dx, move.y + dy)) + * return result +*/ + if (unlikely(__pyx_v_orient->corners == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 536, __pyx_L1_error) + } + __pyx_t_3 = __pyx_v_orient->corners; __Pyx_INCREF(__pyx_t_3); + __pyx_t_5 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 536, __pyx_L1_error) + #endif + if (__pyx_t_5 >= __pyx_temp) break; + } + __pyx_t_1 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_3, __pyx_t_5, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_5; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 536, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if ((likely(PyTuple_CheckExact(__pyx_t_1))) || (PyList_CheckExact(__pyx_t_1))) { + PyObject* sequence = __pyx_t_1; + Py_ssize_t size = __Pyx_PySequence_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 536, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_6 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_6); + } else { + __pyx_t_2 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 536, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 536, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_6); + } + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 536, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 536, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_7 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 536, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_7); + index = 0; __pyx_t_2 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_2)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + index = 1; __pyx_t_6 = __pyx_t_8(__pyx_t_7); if (unlikely(!__pyx_t_6)) goto __pyx_L5_unpacking_failed; + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_8(__pyx_t_7), 2) < (0)) __PYX_ERR(0, 536, __pyx_L1_error) + __pyx_t_8 = NULL; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + goto __pyx_L6_unpacking_done; + __pyx_L5_unpacking_failed:; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 536, __pyx_L1_error) + __pyx_L6_unpacking_done:; + } + __pyx_t_9 = __Pyx_PyLong_As_int(__pyx_t_2); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 536, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_10 = __Pyx_PyLong_As_int(__pyx_t_6); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 536, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_v_dx = __pyx_t_9; + __pyx_v_dy = __pyx_t_10; + + /* "blokus_gym/core/blokus_cython.pyx":537 + * cdef int dx, dy + * for dx, dy in orient.corners: + * result.append((move.x + dx, move.y + dy)) # <<<<<<<<<<<<<< + * return result + * +*/ + __pyx_t_1 = __Pyx_PyLong_From_int((__pyx_v_move->x + __pyx_v_dx)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 537, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = __Pyx_PyLong_From_int((__pyx_v_move->y + __pyx_v_dy)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 537, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 537, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 537, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 537, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_6 = 0; + __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_result, __pyx_t_2); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 537, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":536 + * cdef list result = [] + * cdef int dx, dy + * for dx, dy in orient.corners: # <<<<<<<<<<<<<< + * result.append((move.x + dx, move.y + dy)) + * return result +*/ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":538 + * for dx, dy in orient.corners: + * result.append((move.x + dx, move.y + dy)) + * return result # <<<<<<<<<<<<<< + * + * cpdef bint valid_move(self, int player_idx, Move move): +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":531 + * return result + * + * cdef list _get_placed_corners(self, Move move): # <<<<<<<<<<<<<< + * """Get the absolute corner coordinates for a move.""" + * cdef PieceOrientation orient = self.piece_set.get_orientations(move.piece_id)[move.orientation_id] +*/ + + /* 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_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame._get_placed_corners", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_orient); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":540 + * return result + * + * cpdef bint valid_move(self, int player_idx, Move move): # <<<<<<<<<<<<<< + * """Check if a move is valid for the given player.""" + * cdef PlayerState player = self.players[player_idx] +*/ + +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_9valid_move(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static int __pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame_valid_move(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, int __pyx_v_player_idx, struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_move, int __pyx_skip_dispatch) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_player = 0; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_piece = 0; + PyObject *__pyx_v_placed_squares = 0; + PyObject *__pyx_v_placed_corners = 0; + int __pyx_v_x; + int __pyx_v_y; + int __pyx_v_player_board_idx; + PyObject *__pyx_v_player_occupied = 0; + int __pyx_v_result; + PyObject *__pyx_v_start_corner = NULL; + PyObject *__pyx_v_dx = NULL; + PyObject *__pyx_v_dy = NULL; + PyObject *__pyx_v_cx = NULL; + PyObject *__pyx_v_cy = NULL; + 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; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + int __pyx_t_7; + Py_ssize_t __pyx_t_8; + PyObject *(*__pyx_t_9)(PyObject *); + int __pyx_t_10; + int __pyx_t_11; + int __pyx_t_12; + Py_ssize_t __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("valid_move", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if ( + #if !CYTHON_USE_TYPE_SLOTS + unlikely(Py_TYPE(((PyObject *)__pyx_v_self)) != __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame && + __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), Py_TPFLAGS_HAVE_GC)) + #else + unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0 || __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE))) + #endif + ) { + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; + if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { + PY_UINT64_T __pyx_typedict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); + #endif + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_valid_move); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 540, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!__Pyx_IsSameCFunction(__pyx_t_1, (void(*)(void)) __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_9valid_move)) { + __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_player_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 540, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_5, ((PyObject *)__pyx_v_move)}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 540, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 540, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_7; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); + __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); + if (unlikely(__pyx_typedict_guard != __pyx_tp_dict_version)) { + __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; + } + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + } + #endif + } + + /* "blokus_gym/core/blokus_cython.pyx":542 + * cpdef bint valid_move(self, int player_idx, Move move): + * """Check if a move is valid for the given player.""" + * cdef PlayerState player = self.players[player_idx] # <<<<<<<<<<<<<< + * cdef Piece piece = self.piece_set.get_piece(move.piece_id) + * cdef list placed_squares = self._get_placed_squares(move) +*/ + if (unlikely(__pyx_v_self->players == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 542, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_self->players, __pyx_v_player_idx, int, 1, __Pyx_PyLong_From_int, 1, 1, 1, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 542, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState))))) __PYX_ERR(0, 542, __pyx_L1_error) + __pyx_v_player = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":543 + * """Check if a move is valid for the given player.""" + * cdef PlayerState player = self.players[player_idx] + * cdef Piece piece = self.piece_set.get_piece(move.piece_id) # <<<<<<<<<<<<<< + * cdef list placed_squares = self._get_placed_squares(move) + * cdef list placed_corners = self._get_placed_corners(move) +*/ + __pyx_t_2 = ((PyObject *)__pyx_v_self->piece_set); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_move->piece_id); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get_piece, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __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(0, 543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece))))) __PYX_ERR(0, 543, __pyx_L1_error) + __pyx_v_piece = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":544 + * cdef PlayerState player = self.players[player_idx] + * cdef Piece piece = self.piece_set.get_piece(move.piece_id) + * cdef list placed_squares = self._get_placed_squares(move) # <<<<<<<<<<<<<< + * cdef list placed_corners = self._get_placed_corners(move) + * cdef int x, y +*/ + __pyx_t_1 = ((struct __pyx_vtabstruct_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self->__pyx_vtab)->_get_placed_squares(__pyx_v_self, __pyx_v_move); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 544, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_placed_squares = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":545 + * cdef Piece piece = self.piece_set.get_piece(move.piece_id) + * cdef list placed_squares = self._get_placed_squares(move) + * cdef list placed_corners = self._get_placed_corners(move) # <<<<<<<<<<<<<< + * cdef int x, y + * cdef int player_board_idx = player_idx + 1 +*/ + __pyx_t_1 = ((struct __pyx_vtabstruct_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self->__pyx_vtab)->_get_placed_corners(__pyx_v_self, __pyx_v_move); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 545, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_placed_corners = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":547 + * cdef list placed_corners = self._get_placed_corners(move) + * cdef int x, y + * cdef int player_board_idx = player_idx + 1 # <<<<<<<<<<<<<< + * cdef set player_occupied + * cdef bint result +*/ + __pyx_v_player_board_idx = (__pyx_v_player_idx + 1); + + /* "blokus_gym/core/blokus_cython.pyx":552 + * + * # Rule 1: Check if player has the piece + * if piece.name not in player.available_pieces: # <<<<<<<<<<<<<< + * return False + * +*/ + if (unlikely(__pyx_v_player->available_pieces == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 552, __pyx_L1_error) + } + __pyx_t_7 = (__Pyx_PySet_ContainsTF(__pyx_v_piece->name, __pyx_v_player->available_pieces, Py_NE)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 552, __pyx_L1_error) + if (__pyx_t_7) { + + /* "blokus_gym/core/blokus_cython.pyx":553 + * # Rule 1: Check if player has the piece + * if piece.name not in player.available_pieces: + * return False # <<<<<<<<<<<<<< + * + * # Rule 2: Check bounds (inline for speed) +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":552 + * + * # Rule 1: Check if player has the piece + * if piece.name not in player.available_pieces: # <<<<<<<<<<<<<< + * return False + * +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":556 + * + * # Rule 2: Check bounds (inline for speed) + * for x, y in placed_squares: # <<<<<<<<<<<<<< + * if not self.board.in_bounds(x, y): + * return False +*/ + if (unlikely(__pyx_v_placed_squares == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 556, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_placed_squares; __Pyx_INCREF(__pyx_t_1); + __pyx_t_8 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 556, __pyx_L1_error) + #endif + if (__pyx_t_8 >= __pyx_temp) break; + } + __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_1, __pyx_t_8, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_8; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 556, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) { + PyObject* sequence = __pyx_t_4; + 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(0, 556, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_5); + } else { + __pyx_t_2 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 556, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 556, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_5); + } + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 556, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 556, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_3 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 556, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); + index = 0; __pyx_t_2 = __pyx_t_9(__pyx_t_3); if (unlikely(!__pyx_t_2)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + index = 1; __pyx_t_5 = __pyx_t_9(__pyx_t_3); if (unlikely(!__pyx_t_5)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_3), 2) < (0)) __PYX_ERR(0, 556, __pyx_L1_error) + __pyx_t_9 = NULL; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L7_unpacking_done; + __pyx_L6_unpacking_failed:; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_9 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 556, __pyx_L1_error) + __pyx_L7_unpacking_done:; + } + __pyx_t_10 = __Pyx_PyLong_As_int(__pyx_t_2); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 556, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_11 = __Pyx_PyLong_As_int(__pyx_t_5); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 556, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_x = __pyx_t_10; + __pyx_v_y = __pyx_t_11; + + /* "blokus_gym/core/blokus_cython.pyx":557 + * # Rule 2: Check bounds (inline for speed) + * for x, y in placed_squares: + * if not self.board.in_bounds(x, y): # <<<<<<<<<<<<<< + * return False + * +*/ + __pyx_t_5 = __pyx_v_self->board; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_x); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_2, __pyx_t_3}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_in_bounds, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 557, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_12 = (!__pyx_t_7); + if (__pyx_t_12) { + + /* "blokus_gym/core/blokus_cython.pyx":558 + * for x, y in placed_squares: + * if not self.board.in_bounds(x, y): + * return False # <<<<<<<<<<<<<< + * + * # Rule 3: Check overlap +*/ + __pyx_r = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":557 + * # Rule 2: Check bounds (inline for speed) + * for x, y in placed_squares: + * if not self.board.in_bounds(x, y): # <<<<<<<<<<<<<< + * return False + * +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":556 + * + * # Rule 2: Check bounds (inline for speed) + * for x, y in placed_squares: # <<<<<<<<<<<<<< + * if not self.board.in_bounds(x, y): + * return False +*/ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":561 + * + * # Rule 3: Check overlap + * if self.board.has_overlap(placed_squares): # <<<<<<<<<<<<<< + * return False + * +*/ + __pyx_t_4 = __pyx_v_self->board; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_placed_squares}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_has_overlap, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 561, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 561, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_12) { + + /* "blokus_gym/core/blokus_cython.pyx":562 + * # Rule 3: Check overlap + * if self.board.has_overlap(placed_squares): + * return False # <<<<<<<<<<<<<< + * + * # Rule 6: First move must be in a corner +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":561 + * + * # Rule 3: Check overlap + * if self.board.has_overlap(placed_squares): # <<<<<<<<<<<<<< + * return False + * +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":565 + * + * # Rule 6: First move must be in a corner + * if self.corner_rule and not player.has_started: # <<<<<<<<<<<<<< + * if len(self.players) <= len(self._starting_corners): + * start_corner = self._starting_corners[player_idx] +*/ + if (__pyx_v_self->corner_rule) { + } else { + __pyx_t_12 = __pyx_v_self->corner_rule; + goto __pyx_L12_bool_binop_done; + } + __pyx_t_7 = (!__pyx_v_player->has_started); + __pyx_t_12 = __pyx_t_7; + __pyx_L12_bool_binop_done:; + if (__pyx_t_12) { + + /* "blokus_gym/core/blokus_cython.pyx":566 + * # Rule 6: First move must be in a corner + * if self.corner_rule and not player.has_started: + * if len(self.players) <= len(self._starting_corners): # <<<<<<<<<<<<<< + * start_corner = self._starting_corners[player_idx] + * if (move.x, move.y) != start_corner: +*/ + __pyx_t_1 = __pyx_v_self->players; + __Pyx_INCREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(0, 566, __pyx_L1_error) + } + __pyx_t_8 = __Pyx_PyList_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(0, 566, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __pyx_v_self->_starting_corners; + __Pyx_INCREF(__pyx_t_1); + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(0, 566, __pyx_L1_error) + } + __pyx_t_13 = __Pyx_PyList_GET_SIZE(__pyx_t_1); if (unlikely(__pyx_t_13 == ((Py_ssize_t)-1))) __PYX_ERR(0, 566, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_12 = (__pyx_t_8 <= __pyx_t_13); + if (__pyx_t_12) { + + /* "blokus_gym/core/blokus_cython.pyx":567 + * if self.corner_rule and not player.has_started: + * if len(self.players) <= len(self._starting_corners): + * start_corner = self._starting_corners[player_idx] # <<<<<<<<<<<<<< + * if (move.x, move.y) != start_corner: + * return False +*/ + if (unlikely(__pyx_v_self->_starting_corners == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 567, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_self->_starting_corners, __pyx_v_player_idx, int, 1, __Pyx_PyLong_From_int, 1, 1, 1, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 567, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_start_corner = __pyx_t_1; + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":568 + * if len(self.players) <= len(self._starting_corners): + * start_corner = self._starting_corners[player_idx] + * if (move.x, move.y) != start_corner: # <<<<<<<<<<<<<< + * return False + * +*/ + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_move->x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_move->y); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 568, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 568, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_v_start_corner, Py_NE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_12) { + + /* "blokus_gym/core/blokus_cython.pyx":569 + * start_corner = self._starting_corners[player_idx] + * if (move.x, move.y) != start_corner: + * return False # <<<<<<<<<<<<<< + * + * # Rule 5: No edge adjacency with same-color pieces (inline for speed) +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":568 + * if len(self.players) <= len(self._starting_corners): + * start_corner = self._starting_corners[player_idx] + * if (move.x, move.y) != start_corner: # <<<<<<<<<<<<<< + * return False + * +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":566 + * # Rule 6: First move must be in a corner + * if self.corner_rule and not player.has_started: + * if len(self.players) <= len(self._starting_corners): # <<<<<<<<<<<<<< + * start_corner = self._starting_corners[player_idx] + * if (move.x, move.y) != start_corner: +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":565 + * + * # Rule 6: First move must be in a corner + * if self.corner_rule and not player.has_started: # <<<<<<<<<<<<<< + * if len(self.players) <= len(self._starting_corners): + * start_corner = self._starting_corners[player_idx] +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":572 + * + * # Rule 5: No edge adjacency with same-color pieces (inline for speed) + * for x, y in placed_squares: # <<<<<<<<<<<<<< + * for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: + * if self.board.in_bounds(x + dx, y + dy): +*/ + if (unlikely(__pyx_v_placed_squares == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 572, __pyx_L1_error) + } + __pyx_t_4 = __pyx_v_placed_squares; __Pyx_INCREF(__pyx_t_4); + __pyx_t_13 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 572, __pyx_L1_error) + #endif + if (__pyx_t_13 >= __pyx_temp) break; + } + __pyx_t_3 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_4, __pyx_t_13, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_13; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if ((likely(PyTuple_CheckExact(__pyx_t_3))) || (PyList_CheckExact(__pyx_t_3))) { + 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(0, 572, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_2); + } else { + __pyx_t_1 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_2); + } + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + #endif + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_5 = PyObject_GetIter(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_5); + index = 0; __pyx_t_1 = __pyx_t_9(__pyx_t_5); if (unlikely(!__pyx_t_1)) goto __pyx_L18_unpacking_failed; + __Pyx_GOTREF(__pyx_t_1); + index = 1; __pyx_t_2 = __pyx_t_9(__pyx_t_5); if (unlikely(!__pyx_t_2)) goto __pyx_L18_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_5), 2) < (0)) __PYX_ERR(0, 572, __pyx_L1_error) + __pyx_t_9 = NULL; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L19_unpacking_done; + __pyx_L18_unpacking_failed:; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_9 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 572, __pyx_L1_error) + __pyx_L19_unpacking_done:; + } + __pyx_t_11 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_11 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_10 = __Pyx_PyLong_As_int(__pyx_t_2); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_x = __pyx_t_11; + __pyx_v_y = __pyx_t_10; + + /* "blokus_gym/core/blokus_cython.pyx":573 + * # Rule 5: No edge adjacency with same-color pieces (inline for speed) + * for x, y in placed_squares: + * for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: # <<<<<<<<<<<<<< + * if self.board.in_bounds(x + dx, y + dy): + * if self.board.get_cell(x + dx, y + dy) == player_board_idx: +*/ + __pyx_t_3 = __pyx_mstate_global->__pyx_tuple[11]; __Pyx_INCREF(__pyx_t_3); + __pyx_t_8 = 0; + for (;;) { + if (__pyx_t_8 >= 4) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_8)); + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_8); + #endif + ++__pyx_t_8; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 573, __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_PyTuple_GET_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 573, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_5 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_5); + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #endif + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(0, 573, __pyx_L1_error) + } + __Pyx_XDECREF_SET(__pyx_v_dx, __pyx_t_1); + __pyx_t_1 = 0; + __Pyx_XDECREF_SET(__pyx_v_dy, __pyx_t_5); + __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":574 + * for x, y in placed_squares: + * for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: + * if self.board.in_bounds(x + dx, y + dy): # <<<<<<<<<<<<<< + * if self.board.get_cell(x + dx, y + dy) == player_board_idx: + * return False +*/ + __pyx_t_5 = __pyx_v_self->board; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_14 = PyNumber_Add(__pyx_t_1, __pyx_v_dx); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_y); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_15 = PyNumber_Add(__pyx_t_1, __pyx_v_dy); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_15); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_14, __pyx_t_15}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_in_bounds, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __Pyx_DECREF(__pyx_t_15); __pyx_t_15 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 574, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_12) { + + /* "blokus_gym/core/blokus_cython.pyx":575 + * for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: + * if self.board.in_bounds(x + dx, y + dy): + * if self.board.get_cell(x + dx, y + dy) == player_board_idx: # <<<<<<<<<<<<<< + * return False + * +*/ + __pyx_t_15 = __pyx_v_self->board; + __Pyx_INCREF(__pyx_t_15); + __pyx_t_14 = __Pyx_PyLong_From_int(__pyx_v_x); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 575, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_5 = PyNumber_Add(__pyx_t_14, __pyx_v_dx); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 575, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __pyx_t_14 = __Pyx_PyLong_From_int(__pyx_v_y); if (unlikely(!__pyx_t_14)) __PYX_ERR(0, 575, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_14); + __pyx_t_1 = PyNumber_Add(__pyx_t_14, __pyx_v_dy); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 575, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_14); __pyx_t_14 = 0; + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_15, __pyx_t_5, __pyx_t_1}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get_cell, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_15); __pyx_t_15 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 575, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_player_board_idx); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 575, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = PyObject_RichCompare(__pyx_t_2, __pyx_t_1, Py_EQ); __Pyx_XGOTREF(__pyx_t_5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 575, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 575, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__pyx_t_12) { + + /* "blokus_gym/core/blokus_cython.pyx":576 + * if self.board.in_bounds(x + dx, y + dy): + * if self.board.get_cell(x + dx, y + dy) == player_board_idx: + * return False # <<<<<<<<<<<<<< + * + * # Rule 4: Corner rule (must touch same-color at a corner) +*/ + __pyx_r = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":575 + * for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: + * if self.board.in_bounds(x + dx, y + dy): + * if self.board.get_cell(x + dx, y + dy) == player_board_idx: # <<<<<<<<<<<<<< + * return False + * +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":574 + * for x, y in placed_squares: + * for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: + * if self.board.in_bounds(x + dx, y + dy): # <<<<<<<<<<<<<< + * if self.board.get_cell(x + dx, y + dy) == player_board_idx: + * return False +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":573 + * # Rule 5: No edge adjacency with same-color pieces (inline for speed) + * for x, y in placed_squares: + * for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: # <<<<<<<<<<<<<< + * if self.board.in_bounds(x + dx, y + dy): + * if self.board.get_cell(x + dx, y + dy) == player_board_idx: +*/ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":572 + * + * # Rule 5: No edge adjacency with same-color pieces (inline for speed) + * for x, y in placed_squares: # <<<<<<<<<<<<<< + * for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: + * if self.board.in_bounds(x + dx, y + dy): +*/ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":579 + * + * # Rule 4: Corner rule (must touch same-color at a corner) + * if player.has_started: # <<<<<<<<<<<<<< + * player_occupied = self.board.get_player_occupied(player_idx) + * # Manual any() implementation - Cython doesn't support generator expressions +*/ + if (__pyx_v_player->has_started) { + + /* "blokus_gym/core/blokus_cython.pyx":580 + * # Rule 4: Corner rule (must touch same-color at a corner) + * if player.has_started: + * player_occupied = self.board.get_player_occupied(player_idx) # <<<<<<<<<<<<<< + * # Manual any() implementation - Cython doesn't support generator expressions + * result = False +*/ + __pyx_t_3 = __pyx_v_self->board; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_player_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 580, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get_player_occupied, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 580, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + if (!(likely(PySet_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None) || __Pyx_RaiseUnexpectedTypeError("set", __pyx_t_4))) __PYX_ERR(0, 580, __pyx_L1_error) + __pyx_v_player_occupied = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":582 + * player_occupied = self.board.get_player_occupied(player_idx) + * # Manual any() implementation - Cython doesn't support generator expressions + * result = False # <<<<<<<<<<<<<< + * for cx, cy in placed_corners: + * if self.board.in_bounds(cx, cy) and (cx, cy) in player_occupied: +*/ + __pyx_v_result = 0; + + /* "blokus_gym/core/blokus_cython.pyx":583 + * # Manual any() implementation - Cython doesn't support generator expressions + * result = False + * for cx, cy in placed_corners: # <<<<<<<<<<<<<< + * if self.board.in_bounds(cx, cy) and (cx, cy) in player_occupied: + * result = True +*/ + if (unlikely(__pyx_v_placed_corners == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 583, __pyx_L1_error) + } + __pyx_t_4 = __pyx_v_placed_corners; __Pyx_INCREF(__pyx_t_4); + __pyx_t_13 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 583, __pyx_L1_error) + #endif + if (__pyx_t_13 >= __pyx_temp) break; + } + __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_4, __pyx_t_13, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_13; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if ((likely(PyTuple_CheckExact(__pyx_t_5))) || (PyList_CheckExact(__pyx_t_5))) { + PyObject* sequence = __pyx_t_5; + 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(0, 583, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_1 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_1); + } else { + __pyx_t_3 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 583, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 583, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_1); + } + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + #endif + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_2 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_9 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); + index = 0; __pyx_t_3 = __pyx_t_9(__pyx_t_2); if (unlikely(!__pyx_t_3)) goto __pyx_L29_unpacking_failed; + __Pyx_GOTREF(__pyx_t_3); + index = 1; __pyx_t_1 = __pyx_t_9(__pyx_t_2); if (unlikely(!__pyx_t_1)) goto __pyx_L29_unpacking_failed; + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_9(__pyx_t_2), 2) < (0)) __PYX_ERR(0, 583, __pyx_L1_error) + __pyx_t_9 = NULL; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + goto __pyx_L30_unpacking_done; + __pyx_L29_unpacking_failed:; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_9 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 583, __pyx_L1_error) + __pyx_L30_unpacking_done:; + } + __Pyx_XDECREF_SET(__pyx_v_cx, __pyx_t_3); + __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_cy, __pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":584 + * result = False + * for cx, cy in placed_corners: + * if self.board.in_bounds(cx, cy) and (cx, cy) in player_occupied: # <<<<<<<<<<<<<< + * result = True + * break +*/ + __pyx_t_1 = __pyx_v_self->board; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_v_cx, __pyx_v_cy}; + __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_in_bounds, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 584, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 584, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__pyx_t_7) { + } else { + __pyx_t_12 = __pyx_t_7; + goto __pyx_L32_bool_binop_done; + } + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 584, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_v_cx); + __Pyx_GIVEREF(__pyx_v_cx); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_v_cx) != (0)) __PYX_ERR(0, 584, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_cy); + __Pyx_GIVEREF(__pyx_v_cy); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_v_cy) != (0)) __PYX_ERR(0, 584, __pyx_L1_error); + if (unlikely(__pyx_v_player_occupied == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 584, __pyx_L1_error) + } + __pyx_t_7 = (__Pyx_PySet_ContainsTF(__pyx_t_5, __pyx_v_player_occupied, Py_EQ)); if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 584, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_12 = __pyx_t_7; + __pyx_L32_bool_binop_done:; + if (__pyx_t_12) { + + /* "blokus_gym/core/blokus_cython.pyx":585 + * for cx, cy in placed_corners: + * if self.board.in_bounds(cx, cy) and (cx, cy) in player_occupied: + * result = True # <<<<<<<<<<<<<< + * break + * if not result: +*/ + __pyx_v_result = 1; + + /* "blokus_gym/core/blokus_cython.pyx":586 + * if self.board.in_bounds(cx, cy) and (cx, cy) in player_occupied: + * result = True + * break # <<<<<<<<<<<<<< + * if not result: + * return False +*/ + goto __pyx_L28_break; + + /* "blokus_gym/core/blokus_cython.pyx":584 + * result = False + * for cx, cy in placed_corners: + * if self.board.in_bounds(cx, cy) and (cx, cy) in player_occupied: # <<<<<<<<<<<<<< + * result = True + * break +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":583 + * # Manual any() implementation - Cython doesn't support generator expressions + * result = False + * for cx, cy in placed_corners: # <<<<<<<<<<<<<< + * if self.board.in_bounds(cx, cy) and (cx, cy) in player_occupied: + * result = True +*/ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L34_for_end; + __pyx_L28_break:; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L34_for_end; + __pyx_L34_for_end:; + + /* "blokus_gym/core/blokus_cython.pyx":587 + * result = True + * break + * if not result: # <<<<<<<<<<<<<< + * return False + * +*/ + __pyx_t_12 = (!__pyx_v_result); + if (__pyx_t_12) { + + /* "blokus_gym/core/blokus_cython.pyx":588 + * break + * if not result: + * return False # <<<<<<<<<<<<<< + * + * return True +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":587 + * result = True + * break + * if not result: # <<<<<<<<<<<<<< + * return False + * +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":579 + * + * # Rule 4: Corner rule (must touch same-color at a corner) + * if player.has_started: # <<<<<<<<<<<<<< + * player_occupied = self.board.get_player_occupied(player_idx) + * # Manual any() implementation - Cython doesn't support generator expressions +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":590 + * return False + * + * return True # <<<<<<<<<<<<<< + * + * cpdef get_valid_actions(self, int player_idx): +*/ + __pyx_r = 1; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":540 + * return result + * + * cpdef bint valid_move(self, int player_idx, Move move): # <<<<<<<<<<<<<< + * """Check if a move is valid for the given player.""" + * cdef PlayerState player = self.players[player_idx] +*/ + + /* 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_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_14); + __Pyx_XDECREF(__pyx_t_15); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.valid_move", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_player); + __Pyx_XDECREF((PyObject *)__pyx_v_piece); + __Pyx_XDECREF(__pyx_v_placed_squares); + __Pyx_XDECREF(__pyx_v_placed_corners); + __Pyx_XDECREF(__pyx_v_player_occupied); + __Pyx_XDECREF(__pyx_v_start_corner); + __Pyx_XDECREF(__pyx_v_dx); + __Pyx_XDECREF(__pyx_v_dy); + __Pyx_XDECREF(__pyx_v_cx); + __Pyx_XDECREF(__pyx_v_cy); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_9valid_move(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_8valid_move, "Check if a move is valid for the given player."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_9valid_move = {"valid_move", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_9valid_move, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_8valid_move}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_9valid_move(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + int __pyx_v_player_idx; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_move = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("valid_move (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_player_idx,&__pyx_mstate_global->__pyx_n_u_move,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 540, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 540, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 540, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "valid_move", 0) < (0)) __PYX_ERR(0, 540, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("valid_move", 1, 2, 2, i); __PYX_ERR(0, 540, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 540, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 540, __pyx_L3_error) + } + __pyx_v_player_idx = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_player_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 540, __pyx_L3_error) + __pyx_v_move = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("valid_move", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 540, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.valid_move", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_move), __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move, 1, "move", 0))) __PYX_ERR(0, 540, __pyx_L1_error) + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_8valid_move(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), __pyx_v_player_idx, __pyx_v_move); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_8valid_move(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, int __pyx_v_player_idx, struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_move) { + 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("valid_move", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame_valid_move(__pyx_v_self, __pyx_v_player_idx, __pyx_v_move, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 540, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 540, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.valid_move", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":592 + * return True + * + * cpdef get_valid_actions(self, int player_idx): # <<<<<<<<<<<<<< + * """Get a boolean mask of valid actions for the given player.""" + * cdef PlayerState player = self.players[player_idx] +*/ + +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_11get_valid_actions(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame_get_valid_actions(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, int __pyx_v_player_idx, int __pyx_skip_dispatch) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_player = 0; + PyArrayObject *__pyx_v_mask = 0; + PyObject *__pyx_v_available_piece_ids = 0; + int __pyx_v_piece_id; + int __pyx_v_action_idx; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_move = 0; + PyObject *__pyx_v_placed_corners = 0; + PyObject *__pyx_v_placed_squares = 0; + int __pyx_v_x; + int __pyx_v_y; + int __pyx_v_player_board_idx; + PyObject *__pyx_v_player_occupied = 0; + int __pyx_v_edge_invalid; + int __pyx_v_result; + int __pyx_v_cx; + int __pyx_v_cy; + PyObject *__pyx_v_name = NULL; + PyObject *__pyx_v_dx = NULL; + PyObject *__pyx_v_dy = 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; + size_t __pyx_t_6; + Py_ssize_t __pyx_t_7; + Py_ssize_t __pyx_t_8; + int __pyx_t_9; + int __pyx_t_10; + int __pyx_t_11; + int __pyx_t_12; + int __pyx_t_13; + int __pyx_t_14; + PyObject *(*__pyx_t_15)(PyObject *); + Py_ssize_t __pyx_t_16; + PyObject *__pyx_t_17 = NULL; + PyObject *__pyx_t_18 = NULL; + PyObject *(*__pyx_t_19)(PyObject *); + Py_ssize_t __pyx_t_20; + PyObject *__pyx_t_21 = NULL; + PyObject *__pyx_t_22 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_valid_actions", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if ( + #if !CYTHON_USE_TYPE_SLOTS + unlikely(Py_TYPE(((PyObject *)__pyx_v_self)) != __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame && + __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), Py_TPFLAGS_HAVE_GC)) + #else + unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0 || __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE))) + #endif + ) { + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; + if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { + PY_UINT64_T __pyx_typedict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); + #endif + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_get_valid_actions); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!__Pyx_IsSameCFunction(__pyx_t_1, (void(*)(void)) __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_11get_valid_actions)) { + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_player_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); + __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); + if (unlikely(__pyx_typedict_guard != __pyx_tp_dict_version)) { + __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; + } + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + } + #endif + } + + /* "blokus_gym/core/blokus_cython.pyx":594 + * cpdef get_valid_actions(self, int player_idx): + * """Get a boolean mask of valid actions for the given player.""" + * cdef PlayerState player = self.players[player_idx] # <<<<<<<<<<<<<< + * cdef cnp.ndarray mask = np.zeros(self.num_actions, dtype=bool) + * cdef list available_piece_ids = [] +*/ + if (unlikely(__pyx_v_self->players == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 594, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_self->players, __pyx_v_player_idx, int, 1, __Pyx_PyLong_From_int, 1, 1, 1, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 594, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState))))) __PYX_ERR(0, 594, __pyx_L1_error) + __pyx_v_player = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":595 + * """Get a boolean mask of valid actions for the given player.""" + * cdef PlayerState player = self.players[player_idx] + * cdef cnp.ndarray mask = np.zeros(self.num_actions, dtype=bool) # <<<<<<<<<<<<<< + * cdef list available_piece_ids = [] + * cdef int piece_id, action_idx +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 595, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 595, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_num_actions); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 595, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_2, __pyx_t_4}; + __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 595, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, ((PyObject *)(&PyBool_Type)), __pyx_t_3, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 595, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 595, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 595, __pyx_L1_error) + __pyx_v_mask = ((PyArrayObject *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":596 + * cdef PlayerState player = self.players[player_idx] + * cdef cnp.ndarray mask = np.zeros(self.num_actions, dtype=bool) + * cdef list available_piece_ids = [] # <<<<<<<<<<<<<< + * cdef int piece_id, action_idx + * cdef Move move +*/ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 596, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_available_piece_ids = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":600 + * cdef Move move + * cdef list placed_corners, placed_squares + * cdef int x, y, player_board_idx = player_idx + 1 # <<<<<<<<<<<<<< + * cdef set player_occupied + * cdef bint edge_invalid, result +*/ + __pyx_v_player_board_idx = (__pyx_v_player_idx + 1); + + /* "blokus_gym/core/blokus_cython.pyx":607 + * + * # Build available_piece_ids list + * for name in player.available_pieces: # <<<<<<<<<<<<<< + * available_piece_ids.append(self.piece_set.get_piece_id(name)) + * +*/ + __pyx_t_7 = 0; + __pyx_t_5 = __Pyx_set_iterator(__pyx_v_player->available_pieces, 1, (&__pyx_t_8), (&__pyx_t_9)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 607, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); + __pyx_t_1 = __pyx_t_5; + __pyx_t_5 = 0; + while (1) { + __pyx_t_10 = __Pyx_set_iter_next(__pyx_t_1, __pyx_t_8, &__pyx_t_7, &__pyx_t_5, __pyx_t_9); + if (unlikely(__pyx_t_10 == 0)) break; + if (unlikely(__pyx_t_10 == -1)) __PYX_ERR(0, 607, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_5); + __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":608 + * # Build available_piece_ids list + * for name in player.available_pieces: + * available_piece_ids.append(self.piece_set.get_piece_id(name)) # <<<<<<<<<<<<<< + * + * if not player.can_move: +*/ + __pyx_t_3 = ((PyObject *)__pyx_v_self->piece_set); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_name}; + __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get_piece_id, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 608, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __pyx_t_11 = __Pyx_PyList_Append(__pyx_v_available_piece_ids, __pyx_t_5); if (unlikely(__pyx_t_11 == ((int)-1))) __PYX_ERR(0, 608, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":610 + * available_piece_ids.append(self.piece_set.get_piece_id(name)) + * + * if not player.can_move: # <<<<<<<<<<<<<< + * return mask + * +*/ + __pyx_t_12 = (!__pyx_v_player->can_move); + if (__pyx_t_12) { + + /* "blokus_gym/core/blokus_cython.pyx":611 + * + * if not player.can_move: + * return mask # <<<<<<<<<<<<<< + * + * if not player.has_started or not player.corners: +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_mask); + __pyx_r = ((PyObject *)__pyx_v_mask); + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":610 + * available_piece_ids.append(self.piece_set.get_piece_id(name)) + * + * if not player.can_move: # <<<<<<<<<<<<<< + * return mask + * +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":613 + * return mask + * + * if not player.has_started or not player.corners: # <<<<<<<<<<<<<< + * for piece_id in available_piece_ids: + * for action_idx in self._actions_by_piece[piece_id]: +*/ + __pyx_t_13 = (!__pyx_v_player->has_started); + if (!__pyx_t_13) { + } else { + __pyx_t_12 = __pyx_t_13; + goto __pyx_L7_bool_binop_done; + } + if (__pyx_v_player->corners == Py_None) __pyx_t_13 = 0; + else + { + Py_ssize_t __pyx_temp = __Pyx_PySet_GET_SIZE(__pyx_v_player->corners); + if (unlikely(((!CYTHON_ASSUME_SAFE_SIZE) && __pyx_temp < 0))) __PYX_ERR(0, 613, __pyx_L1_error) + __pyx_t_13 = (__pyx_temp != 0); + } + + __pyx_t_14 = (!__pyx_t_13); + __pyx_t_12 = __pyx_t_14; + __pyx_L7_bool_binop_done:; + if (__pyx_t_12) { + + /* "blokus_gym/core/blokus_cython.pyx":614 + * + * if not player.has_started or not player.corners: + * for piece_id in available_piece_ids: # <<<<<<<<<<<<<< + * for action_idx in self._actions_by_piece[piece_id]: + * if self.valid_move(player_idx, self._action_moves[action_idx]): +*/ + __pyx_t_1 = __pyx_v_available_piece_ids; __Pyx_INCREF(__pyx_t_1); + __pyx_t_8 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 614, __pyx_L1_error) + #endif + if (__pyx_t_8 >= __pyx_temp) break; + } + __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_1, __pyx_t_8, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_8; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 614, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9 = __Pyx_PyLong_As_int(__pyx_t_5); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 614, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_piece_id = __pyx_t_9; + + /* "blokus_gym/core/blokus_cython.pyx":615 + * if not player.has_started or not player.corners: + * for piece_id in available_piece_ids: + * for action_idx in self._actions_by_piece[piece_id]: # <<<<<<<<<<<<<< + * if self.valid_move(player_idx, self._action_moves[action_idx]): + * mask[action_idx] = True +*/ + if (unlikely(__pyx_v_self->_actions_by_piece == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 615, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_self->_actions_by_piece, __pyx_v_piece_id, int, 1, __Pyx_PyLong_From_int, 1, 1, 1, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (likely(PyList_CheckExact(__pyx_t_5)) || PyTuple_CheckExact(__pyx_t_5)) { + __pyx_t_3 = __pyx_t_5; __Pyx_INCREF(__pyx_t_3); + __pyx_t_7 = 0; + __pyx_t_15 = NULL; + } else { + __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_15 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 615, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + for (;;) { + if (likely(!__pyx_t_15)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 615, __pyx_L1_error) + #endif + if (__pyx_t_7 >= __pyx_temp) break; + } + __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_3, __pyx_t_7, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_7; + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 615, __pyx_L1_error) + #endif + if (__pyx_t_7 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7)); + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_7); + #endif + ++__pyx_t_7; + } + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 615, __pyx_L1_error) + } else { + __pyx_t_5 = __pyx_t_15(__pyx_t_3); + if (unlikely(!__pyx_t_5)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 615, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9 = __Pyx_PyLong_As_int(__pyx_t_5); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 615, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_action_idx = __pyx_t_9; + + /* "blokus_gym/core/blokus_cython.pyx":616 + * for piece_id in available_piece_ids: + * for action_idx in self._actions_by_piece[piece_id]: + * if self.valid_move(player_idx, self._action_moves[action_idx]): # <<<<<<<<<<<<<< + * mask[action_idx] = True + * return mask +*/ + if (unlikely(__pyx_v_self->_action_moves == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 616, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_self->_action_moves, __pyx_v_action_idx, int, 1, __Pyx_PyLong_From_int, 1, 1, 1, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move))))) __PYX_ERR(0, 616, __pyx_L1_error) + __pyx_t_12 = ((struct __pyx_vtabstruct_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self->__pyx_vtab)->valid_move(__pyx_v_self, __pyx_v_player_idx, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)__pyx_t_5), 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 616, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__pyx_t_12) { + + /* "blokus_gym/core/blokus_cython.pyx":617 + * for action_idx in self._actions_by_piece[piece_id]: + * if self.valid_move(player_idx, self._action_moves[action_idx]): + * mask[action_idx] = True # <<<<<<<<<<<<<< + * return mask + * +*/ + if (unlikely((__Pyx_SetItemInt(((PyObject *)__pyx_v_mask), __pyx_v_action_idx, Py_True, int, 1, __Pyx_PyLong_From_int, 0, 1, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference) < 0))) __PYX_ERR(0, 617, __pyx_L1_error) + + /* "blokus_gym/core/blokus_cython.pyx":616 + * for piece_id in available_piece_ids: + * for action_idx in self._actions_by_piece[piece_id]: + * if self.valid_move(player_idx, self._action_moves[action_idx]): # <<<<<<<<<<<<<< + * mask[action_idx] = True + * return mask +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":615 + * if not player.has_started or not player.corners: + * for piece_id in available_piece_ids: + * for action_idx in self._actions_by_piece[piece_id]: # <<<<<<<<<<<<<< + * if self.valid_move(player_idx, self._action_moves[action_idx]): + * mask[action_idx] = True +*/ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":614 + * + * if not player.has_started or not player.corners: + * for piece_id in available_piece_ids: # <<<<<<<<<<<<<< + * for action_idx in self._actions_by_piece[piece_id]: + * if self.valid_move(player_idx, self._action_moves[action_idx]): +*/ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":618 + * if self.valid_move(player_idx, self._action_moves[action_idx]): + * mask[action_idx] = True + * return mask # <<<<<<<<<<<<<< + * + * # Pre-compute player's occupied squares ONCE +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_mask); + __pyx_r = ((PyObject *)__pyx_v_mask); + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":613 + * return mask + * + * if not player.has_started or not player.corners: # <<<<<<<<<<<<<< + * for piece_id in available_piece_ids: + * for action_idx in self._actions_by_piece[piece_id]: +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":621 + * + * # Pre-compute player's occupied squares ONCE + * player_occupied = self.board.get_player_occupied(player_idx + 1) # <<<<<<<<<<<<<< + * + * for piece_id in available_piece_ids: +*/ + __pyx_t_3 = __pyx_v_self->board; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyLong_From_long((__pyx_v_player_idx + 1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 621, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get_player_occupied, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 621, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (!(likely(PySet_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("set", __pyx_t_1))) __PYX_ERR(0, 621, __pyx_L1_error) + __pyx_v_player_occupied = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":623 + * player_occupied = self.board.get_player_occupied(player_idx + 1) + * + * for piece_id in available_piece_ids: # <<<<<<<<<<<<<< + * for action_idx in self._actions_by_piece[piece_id]: + * move = self._action_moves[action_idx] +*/ + __pyx_t_1 = __pyx_v_available_piece_ids; __Pyx_INCREF(__pyx_t_1); + __pyx_t_8 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 623, __pyx_L1_error) + #endif + if (__pyx_t_8 >= __pyx_temp) break; + } + __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_1, __pyx_t_8, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_8; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 623, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9 = __Pyx_PyLong_As_int(__pyx_t_5); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 623, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_piece_id = __pyx_t_9; + + /* "blokus_gym/core/blokus_cython.pyx":624 + * + * for piece_id in available_piece_ids: + * for action_idx in self._actions_by_piece[piece_id]: # <<<<<<<<<<<<<< + * move = self._action_moves[action_idx] + * placed_corners = self._get_placed_corners(move) +*/ + if (unlikely(__pyx_v_self->_actions_by_piece == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 624, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_self->_actions_by_piece, __pyx_v_piece_id, int, 1, __Pyx_PyLong_From_int, 1, 1, 1, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 624, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (likely(PyList_CheckExact(__pyx_t_5)) || PyTuple_CheckExact(__pyx_t_5)) { + __pyx_t_3 = __pyx_t_5; __Pyx_INCREF(__pyx_t_3); + __pyx_t_7 = 0; + __pyx_t_15 = NULL; + } else { + __pyx_t_7 = -1; __pyx_t_3 = PyObject_GetIter(__pyx_t_5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 624, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_15 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_15)) __PYX_ERR(0, 624, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + for (;;) { + if (likely(!__pyx_t_15)) { + if (likely(PyList_CheckExact(__pyx_t_3))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 624, __pyx_L1_error) + #endif + if (__pyx_t_7 >= __pyx_temp) break; + } + __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_3, __pyx_t_7, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_7; + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 624, __pyx_L1_error) + #endif + if (__pyx_t_7 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_3, __pyx_t_7)); + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_3, __pyx_t_7); + #endif + ++__pyx_t_7; + } + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 624, __pyx_L1_error) + } else { + __pyx_t_5 = __pyx_t_15(__pyx_t_3); + if (unlikely(!__pyx_t_5)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 624, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9 = __Pyx_PyLong_As_int(__pyx_t_5); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 624, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_action_idx = __pyx_t_9; + + /* "blokus_gym/core/blokus_cython.pyx":625 + * for piece_id in available_piece_ids: + * for action_idx in self._actions_by_piece[piece_id]: + * move = self._action_moves[action_idx] # <<<<<<<<<<<<<< + * placed_corners = self._get_placed_corners(move) + * +*/ + if (unlikely(__pyx_v_self->_action_moves == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 625, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_GetItemInt_List(__pyx_v_self->_action_moves, __pyx_v_action_idx, int, 1, __Pyx_PyLong_From_int, 1, 1, 1, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (!(likely(((__pyx_t_5) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_5, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move))))) __PYX_ERR(0, 625, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_move, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)__pyx_t_5)); + __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":626 + * for action_idx in self._actions_by_piece[piece_id]: + * move = self._action_moves[action_idx] + * placed_corners = self._get_placed_corners(move) # <<<<<<<<<<<<<< + * + * # Early exit: check corner touch (manual any()) +*/ + __pyx_t_5 = ((struct __pyx_vtabstruct_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self->__pyx_vtab)->_get_placed_corners(__pyx_v_self, __pyx_v_move); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 626, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF_SET(__pyx_v_placed_corners, ((PyObject*)__pyx_t_5)); + __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":629 + * + * # Early exit: check corner touch (manual any()) + * result = False # <<<<<<<<<<<<<< + * for cx, cy in placed_corners: + * if self.board.in_bounds(cx, cy) and (cx, cy) in player_occupied: +*/ + __pyx_v_result = 0; + + /* "blokus_gym/core/blokus_cython.pyx":630 + * # Early exit: check corner touch (manual any()) + * result = False + * for cx, cy in placed_corners: # <<<<<<<<<<<<<< + * if self.board.in_bounds(cx, cy) and (cx, cy) in player_occupied: + * result = True +*/ + if (unlikely(__pyx_v_placed_corners == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 630, __pyx_L1_error) + } + __pyx_t_5 = __pyx_v_placed_corners; __Pyx_INCREF(__pyx_t_5); + __pyx_t_16 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 630, __pyx_L1_error) + #endif + if (__pyx_t_16 >= __pyx_temp) break; + } + __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_5, __pyx_t_16, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_16; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if ((likely(PyTuple_CheckExact(__pyx_t_4))) || (PyList_CheckExact(__pyx_t_4))) { + PyObject* sequence = __pyx_t_4; + 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(0, 630, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_17 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_17); + } else { + __pyx_t_2 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_2); + __pyx_t_17 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_17); + } + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_17 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + #endif + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_18 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_19 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_18); + index = 0; __pyx_t_2 = __pyx_t_19(__pyx_t_18); if (unlikely(!__pyx_t_2)) goto __pyx_L22_unpacking_failed; + __Pyx_GOTREF(__pyx_t_2); + index = 1; __pyx_t_17 = __pyx_t_19(__pyx_t_18); if (unlikely(!__pyx_t_17)) goto __pyx_L22_unpacking_failed; + __Pyx_GOTREF(__pyx_t_17); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_19(__pyx_t_18), 2) < (0)) __PYX_ERR(0, 630, __pyx_L1_error) + __pyx_t_19 = NULL; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + goto __pyx_L23_unpacking_done; + __pyx_L22_unpacking_failed:; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __pyx_t_19 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 630, __pyx_L1_error) + __pyx_L23_unpacking_done:; + } + __pyx_t_9 = __Pyx_PyLong_As_int(__pyx_t_2); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_10 = __Pyx_PyLong_As_int(__pyx_t_17); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 630, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_v_cx = __pyx_t_9; + __pyx_v_cy = __pyx_t_10; + + /* "blokus_gym/core/blokus_cython.pyx":631 + * result = False + * for cx, cy in placed_corners: + * if self.board.in_bounds(cx, cy) and (cx, cy) in player_occupied: # <<<<<<<<<<<<<< + * result = True + * break +*/ + __pyx_t_17 = __pyx_v_self->board; + __Pyx_INCREF(__pyx_t_17); + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_cx); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_18 = __Pyx_PyLong_From_int(__pyx_v_cy); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_17, __pyx_t_2, __pyx_t_18}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_in_bounds, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_17); __pyx_t_17 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 631, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_14) { + } else { + __pyx_t_12 = __pyx_t_14; + goto __pyx_L25_bool_binop_done; + } + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_cx); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_18 = __Pyx_PyLong_From_int(__pyx_v_cy); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __pyx_t_2 = PyTuple_New(2); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 631, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_18); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_18) != (0)) __PYX_ERR(0, 631, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_18 = 0; + if (unlikely(__pyx_v_player_occupied == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 631, __pyx_L1_error) + } + __pyx_t_14 = (__Pyx_PySet_ContainsTF(__pyx_t_2, __pyx_v_player_occupied, Py_EQ)); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 631, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_12 = __pyx_t_14; + __pyx_L25_bool_binop_done:; + if (__pyx_t_12) { + + /* "blokus_gym/core/blokus_cython.pyx":632 + * for cx, cy in placed_corners: + * if self.board.in_bounds(cx, cy) and (cx, cy) in player_occupied: + * result = True # <<<<<<<<<<<<<< + * break + * if not result: +*/ + __pyx_v_result = 1; + + /* "blokus_gym/core/blokus_cython.pyx":633 + * if self.board.in_bounds(cx, cy) and (cx, cy) in player_occupied: + * result = True + * break # <<<<<<<<<<<<<< + * if not result: + * continue +*/ + goto __pyx_L21_break; + + /* "blokus_gym/core/blokus_cython.pyx":631 + * result = False + * for cx, cy in placed_corners: + * if self.board.in_bounds(cx, cy) and (cx, cy) in player_occupied: # <<<<<<<<<<<<<< + * result = True + * break +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":630 + * # Early exit: check corner touch (manual any()) + * result = False + * for cx, cy in placed_corners: # <<<<<<<<<<<<<< + * if self.board.in_bounds(cx, cy) and (cx, cy) in player_occupied: + * result = True +*/ + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L27_for_end; + __pyx_L21_break:; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L27_for_end; + __pyx_L27_for_end:; + + /* "blokus_gym/core/blokus_cython.pyx":634 + * result = True + * break + * if not result: # <<<<<<<<<<<<<< + * continue + * +*/ + __pyx_t_12 = (!__pyx_v_result); + if (__pyx_t_12) { + + /* "blokus_gym/core/blokus_cython.pyx":635 + * break + * if not result: + * continue # <<<<<<<<<<<<<< + * + * placed_squares = self._get_placed_squares(move) +*/ + goto __pyx_L18_continue; + + /* "blokus_gym/core/blokus_cython.pyx":634 + * result = True + * break + * if not result: # <<<<<<<<<<<<<< + * continue + * +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":637 + * continue + * + * placed_squares = self._get_placed_squares(move) # <<<<<<<<<<<<<< + * + * # Check bounds +*/ + __pyx_t_5 = ((struct __pyx_vtabstruct_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self->__pyx_vtab)->_get_placed_squares(__pyx_v_self, __pyx_v_move); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF_SET(__pyx_v_placed_squares, ((PyObject*)__pyx_t_5)); + __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":640 + * + * # Check bounds + * result = True # <<<<<<<<<<<<<< + * for x, y in placed_squares: + * if not self.board.in_bounds(x, y): +*/ + __pyx_v_result = 1; + + /* "blokus_gym/core/blokus_cython.pyx":641 + * # Check bounds + * result = True + * for x, y in placed_squares: # <<<<<<<<<<<<<< + * if not self.board.in_bounds(x, y): + * result = False +*/ + if (unlikely(__pyx_v_placed_squares == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 641, __pyx_L1_error) + } + __pyx_t_5 = __pyx_v_placed_squares; __Pyx_INCREF(__pyx_t_5); + __pyx_t_16 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 641, __pyx_L1_error) + #endif + if (__pyx_t_16 >= __pyx_temp) break; + } + __pyx_t_2 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_5, __pyx_t_16, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_16; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 641, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) { + 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(0, 641, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_18 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_18); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_4); + } else { + __pyx_t_18 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 641, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_18); + __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 641, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_4); + } + #else + __pyx_t_18 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 641, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 641, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_17 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 641, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_19 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_17); + index = 0; __pyx_t_18 = __pyx_t_19(__pyx_t_17); if (unlikely(!__pyx_t_18)) goto __pyx_L31_unpacking_failed; + __Pyx_GOTREF(__pyx_t_18); + index = 1; __pyx_t_4 = __pyx_t_19(__pyx_t_17); if (unlikely(!__pyx_t_4)) goto __pyx_L31_unpacking_failed; + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_19(__pyx_t_17), 2) < (0)) __PYX_ERR(0, 641, __pyx_L1_error) + __pyx_t_19 = NULL; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + goto __pyx_L32_unpacking_done; + __pyx_L31_unpacking_failed:; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_t_19 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 641, __pyx_L1_error) + __pyx_L32_unpacking_done:; + } + __pyx_t_10 = __Pyx_PyLong_As_int(__pyx_t_18); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 641, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __pyx_t_9 = __Pyx_PyLong_As_int(__pyx_t_4); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 641, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_x = __pyx_t_10; + __pyx_v_y = __pyx_t_9; + + /* "blokus_gym/core/blokus_cython.pyx":642 + * result = True + * for x, y in placed_squares: + * if not self.board.in_bounds(x, y): # <<<<<<<<<<<<<< + * result = False + * break +*/ + __pyx_t_4 = __pyx_v_self->board; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_18 = __Pyx_PyLong_From_int(__pyx_v_x); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 642, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __pyx_t_17 = __Pyx_PyLong_From_int(__pyx_v_y); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 642, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_18, __pyx_t_17}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_in_bounds, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 642, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_12 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_12 < 0))) __PYX_ERR(0, 642, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_14 = (!__pyx_t_12); + if (__pyx_t_14) { + + /* "blokus_gym/core/blokus_cython.pyx":643 + * for x, y in placed_squares: + * if not self.board.in_bounds(x, y): + * result = False # <<<<<<<<<<<<<< + * break + * if not result: +*/ + __pyx_v_result = 0; + + /* "blokus_gym/core/blokus_cython.pyx":644 + * if not self.board.in_bounds(x, y): + * result = False + * break # <<<<<<<<<<<<<< + * if not result: + * continue +*/ + goto __pyx_L30_break; + + /* "blokus_gym/core/blokus_cython.pyx":642 + * result = True + * for x, y in placed_squares: + * if not self.board.in_bounds(x, y): # <<<<<<<<<<<<<< + * result = False + * break +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":641 + * # Check bounds + * result = True + * for x, y in placed_squares: # <<<<<<<<<<<<<< + * if not self.board.in_bounds(x, y): + * result = False +*/ + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L34_for_end; + __pyx_L30_break:; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L34_for_end; + __pyx_L34_for_end:; + + /* "blokus_gym/core/blokus_cython.pyx":645 + * result = False + * break + * if not result: # <<<<<<<<<<<<<< + * continue + * +*/ + __pyx_t_14 = (!__pyx_v_result); + if (__pyx_t_14) { + + /* "blokus_gym/core/blokus_cython.pyx":646 + * break + * if not result: + * continue # <<<<<<<<<<<<<< + * + * # Check overlap +*/ + goto __pyx_L18_continue; + + /* "blokus_gym/core/blokus_cython.pyx":645 + * result = False + * break + * if not result: # <<<<<<<<<<<<<< + * continue + * +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":649 + * + * # Check overlap + * if self.board.has_overlap(placed_squares): # <<<<<<<<<<<<<< + * continue + * +*/ + __pyx_t_2 = __pyx_v_self->board; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_placed_squares}; + __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_has_overlap, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 649, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_5); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 649, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__pyx_t_14) { + + /* "blokus_gym/core/blokus_cython.pyx":650 + * # Check overlap + * if self.board.has_overlap(placed_squares): + * continue # <<<<<<<<<<<<<< + * + * # Check edge adjacency (inline for speed) +*/ + goto __pyx_L18_continue; + + /* "blokus_gym/core/blokus_cython.pyx":649 + * + * # Check overlap + * if self.board.has_overlap(placed_squares): # <<<<<<<<<<<<<< + * continue + * +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":653 + * + * # Check edge adjacency (inline for speed) + * edge_invalid = False # <<<<<<<<<<<<<< + * for x, y in placed_squares: + * for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: +*/ + __pyx_v_edge_invalid = 0; + + /* "blokus_gym/core/blokus_cython.pyx":654 + * # Check edge adjacency (inline for speed) + * edge_invalid = False + * for x, y in placed_squares: # <<<<<<<<<<<<<< + * for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: + * if self.board.in_bounds(x + dx, y + dy): +*/ + if (unlikely(__pyx_v_placed_squares == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 654, __pyx_L1_error) + } + __pyx_t_5 = __pyx_v_placed_squares; __Pyx_INCREF(__pyx_t_5); + __pyx_t_16 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_5); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 654, __pyx_L1_error) + #endif + if (__pyx_t_16 >= __pyx_temp) break; + } + __pyx_t_2 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_5, __pyx_t_16, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_16; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 654, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) { + 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(0, 654, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_17 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_17); + __pyx_t_18 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_18); + } else { + __pyx_t_17 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 654, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_17); + __pyx_t_18 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 654, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_18); + } + #else + __pyx_t_17 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 654, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_18 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 654, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + #endif + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_4 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 654, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_19 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); + index = 0; __pyx_t_17 = __pyx_t_19(__pyx_t_4); if (unlikely(!__pyx_t_17)) goto __pyx_L39_unpacking_failed; + __Pyx_GOTREF(__pyx_t_17); + index = 1; __pyx_t_18 = __pyx_t_19(__pyx_t_4); if (unlikely(!__pyx_t_18)) goto __pyx_L39_unpacking_failed; + __Pyx_GOTREF(__pyx_t_18); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_19(__pyx_t_4), 2) < (0)) __PYX_ERR(0, 654, __pyx_L1_error) + __pyx_t_19 = NULL; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L40_unpacking_done; + __pyx_L39_unpacking_failed:; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_19 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 654, __pyx_L1_error) + __pyx_L40_unpacking_done:; + } + __pyx_t_9 = __Pyx_PyLong_As_int(__pyx_t_17); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 654, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_t_10 = __Pyx_PyLong_As_int(__pyx_t_18); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 654, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __pyx_v_x = __pyx_t_9; + __pyx_v_y = __pyx_t_10; + + /* "blokus_gym/core/blokus_cython.pyx":655 + * edge_invalid = False + * for x, y in placed_squares: + * for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: # <<<<<<<<<<<<<< + * if self.board.in_bounds(x + dx, y + dy): + * if self.board.get_cell(x + dx, y + dy) == player_board_idx: +*/ + __pyx_t_2 = __pyx_mstate_global->__pyx_tuple[11]; __Pyx_INCREF(__pyx_t_2); + __pyx_t_20 = 0; + for (;;) { + if (__pyx_t_20 >= 4) break; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_18 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_20)); + #else + __pyx_t_18 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_20); + #endif + ++__pyx_t_20; + if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 655, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + if (likely(__pyx_t_18 != Py_None)) { + PyObject* sequence = __pyx_t_18; + Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(0, 655, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_17 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_17); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_17 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 655, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 655, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(0, 655, __pyx_L1_error) + } + __Pyx_XDECREF_SET(__pyx_v_dx, __pyx_t_17); + __pyx_t_17 = 0; + __Pyx_XDECREF_SET(__pyx_v_dy, __pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":656 + * for x, y in placed_squares: + * for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: + * if self.board.in_bounds(x + dx, y + dy): # <<<<<<<<<<<<<< + * if self.board.get_cell(x + dx, y + dy) == player_board_idx: + * edge_invalid = True +*/ + __pyx_t_4 = __pyx_v_self->board; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_17 = __Pyx_PyLong_From_int(__pyx_v_x); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 656, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_21 = PyNumber_Add(__pyx_t_17, __pyx_v_dx); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 656, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_t_17 = __Pyx_PyLong_From_int(__pyx_v_y); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 656, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_22 = PyNumber_Add(__pyx_t_17, __pyx_v_dy); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 656, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_21, __pyx_t_22}; + __pyx_t_18 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_in_bounds, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 656, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + } + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_18); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 656, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + if (__pyx_t_14) { + + /* "blokus_gym/core/blokus_cython.pyx":657 + * for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: + * if self.board.in_bounds(x + dx, y + dy): + * if self.board.get_cell(x + dx, y + dy) == player_board_idx: # <<<<<<<<<<<<<< + * edge_invalid = True + * break +*/ + __pyx_t_22 = __pyx_v_self->board; + __Pyx_INCREF(__pyx_t_22); + __pyx_t_21 = __Pyx_PyLong_From_int(__pyx_v_x); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 657, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + __pyx_t_4 = PyNumber_Add(__pyx_t_21, __pyx_v_dx); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 657, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + __pyx_t_21 = __Pyx_PyLong_From_int(__pyx_v_y); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 657, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + __pyx_t_17 = PyNumber_Add(__pyx_t_21, __pyx_v_dy); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 657, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_22, __pyx_t_4, __pyx_t_17}; + __pyx_t_18 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get_cell, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 657, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + } + __pyx_t_17 = __Pyx_PyLong_From_int(__pyx_v_player_board_idx); if (unlikely(!__pyx_t_17)) __PYX_ERR(0, 657, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_17); + __pyx_t_4 = PyObject_RichCompare(__pyx_t_18, __pyx_t_17, Py_EQ); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 657, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_DECREF(__pyx_t_17); __pyx_t_17 = 0; + __pyx_t_14 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_14 < 0))) __PYX_ERR(0, 657, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_14) { + + /* "blokus_gym/core/blokus_cython.pyx":658 + * if self.board.in_bounds(x + dx, y + dy): + * if self.board.get_cell(x + dx, y + dy) == player_board_idx: + * edge_invalid = True # <<<<<<<<<<<<<< + * break + * if edge_invalid: +*/ + __pyx_v_edge_invalid = 1; + + /* "blokus_gym/core/blokus_cython.pyx":659 + * if self.board.get_cell(x + dx, y + dy) == player_board_idx: + * edge_invalid = True + * break # <<<<<<<<<<<<<< + * if edge_invalid: + * break +*/ + goto __pyx_L42_break; + + /* "blokus_gym/core/blokus_cython.pyx":657 + * for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: + * if self.board.in_bounds(x + dx, y + dy): + * if self.board.get_cell(x + dx, y + dy) == player_board_idx: # <<<<<<<<<<<<<< + * edge_invalid = True + * break +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":656 + * for x, y in placed_squares: + * for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: + * if self.board.in_bounds(x + dx, y + dy): # <<<<<<<<<<<<<< + * if self.board.get_cell(x + dx, y + dy) == player_board_idx: + * edge_invalid = True +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":655 + * edge_invalid = False + * for x, y in placed_squares: + * for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: # <<<<<<<<<<<<<< + * if self.board.in_bounds(x + dx, y + dy): + * if self.board.get_cell(x + dx, y + dy) == player_board_idx: +*/ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + goto __pyx_L45_for_end; + __pyx_L42_break:; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + goto __pyx_L45_for_end; + __pyx_L45_for_end:; + + /* "blokus_gym/core/blokus_cython.pyx":660 + * edge_invalid = True + * break + * if edge_invalid: # <<<<<<<<<<<<<< + * break + * +*/ + if (__pyx_v_edge_invalid) { + + /* "blokus_gym/core/blokus_cython.pyx":661 + * break + * if edge_invalid: + * break # <<<<<<<<<<<<<< + * + * if not edge_invalid: +*/ + goto __pyx_L38_break; + + /* "blokus_gym/core/blokus_cython.pyx":660 + * edge_invalid = True + * break + * if edge_invalid: # <<<<<<<<<<<<<< + * break + * +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":654 + * # Check edge adjacency (inline for speed) + * edge_invalid = False + * for x, y in placed_squares: # <<<<<<<<<<<<<< + * for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: + * if self.board.in_bounds(x + dx, y + dy): +*/ + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L47_for_end; + __pyx_L38_break:; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L47_for_end; + __pyx_L47_for_end:; + + /* "blokus_gym/core/blokus_cython.pyx":663 + * break + * + * if not edge_invalid: # <<<<<<<<<<<<<< + * mask[action_idx] = True + * +*/ + __pyx_t_14 = (!__pyx_v_edge_invalid); + if (__pyx_t_14) { + + /* "blokus_gym/core/blokus_cython.pyx":664 + * + * if not edge_invalid: + * mask[action_idx] = True # <<<<<<<<<<<<<< + * + * return mask +*/ + if (unlikely((__Pyx_SetItemInt(((PyObject *)__pyx_v_mask), __pyx_v_action_idx, Py_True, int, 1, __Pyx_PyLong_From_int, 0, 1, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference) < 0))) __PYX_ERR(0, 664, __pyx_L1_error) + + /* "blokus_gym/core/blokus_cython.pyx":663 + * break + * + * if not edge_invalid: # <<<<<<<<<<<<<< + * mask[action_idx] = True + * +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":624 + * + * for piece_id in available_piece_ids: + * for action_idx in self._actions_by_piece[piece_id]: # <<<<<<<<<<<<<< + * move = self._action_moves[action_idx] + * placed_corners = self._get_placed_corners(move) +*/ + __pyx_L18_continue:; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":623 + * player_occupied = self.board.get_player_occupied(player_idx + 1) + * + * for piece_id in available_piece_ids: # <<<<<<<<<<<<<< + * for action_idx in self._actions_by_piece[piece_id]: + * move = self._action_moves[action_idx] +*/ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":666 + * mask[action_idx] = True + * + * return mask # <<<<<<<<<<<<<< + * + * cpdef bint has_valid_moves(self, int player_idx): +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_mask); + __pyx_r = ((PyObject *)__pyx_v_mask); + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":592 + * return True + * + * cpdef get_valid_actions(self, int player_idx): # <<<<<<<<<<<<<< + * """Get a boolean mask of valid actions for the given player.""" + * cdef PlayerState player = self.players[player_idx] +*/ + + /* 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_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_17); + __Pyx_XDECREF(__pyx_t_18); + __Pyx_XDECREF(__pyx_t_21); + __Pyx_XDECREF(__pyx_t_22); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.get_valid_actions", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_player); + __Pyx_XDECREF((PyObject *)__pyx_v_mask); + __Pyx_XDECREF(__pyx_v_available_piece_ids); + __Pyx_XDECREF((PyObject *)__pyx_v_move); + __Pyx_XDECREF(__pyx_v_placed_corners); + __Pyx_XDECREF(__pyx_v_placed_squares); + __Pyx_XDECREF(__pyx_v_player_occupied); + __Pyx_XDECREF(__pyx_v_name); + __Pyx_XDECREF(__pyx_v_dx); + __Pyx_XDECREF(__pyx_v_dy); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_11get_valid_actions(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_10get_valid_actions, "Get a boolean mask of valid actions for the given player."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_11get_valid_actions = {"get_valid_actions", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_11get_valid_actions, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_10get_valid_actions}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_11get_valid_actions(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + int __pyx_v_player_idx; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_valid_actions (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_player_idx,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 592, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 592, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "get_valid_actions", 0) < (0)) __PYX_ERR(0, 592, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("get_valid_actions", 1, 1, 1, i); __PYX_ERR(0, 592, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 592, __pyx_L3_error) + } + __pyx_v_player_idx = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_player_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 592, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("get_valid_actions", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 592, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.get_valid_actions", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_10get_valid_actions(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), __pyx_v_player_idx); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_10get_valid_actions(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, int __pyx_v_player_idx) { + 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_valid_actions", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame_get_valid_actions(__pyx_v_self, __pyx_v_player_idx, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 592, __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("blokus_gym.core.blokus_cython.BlokusGame.get_valid_actions", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":668 + * return mask + * + * cpdef bint has_valid_moves(self, int player_idx): # <<<<<<<<<<<<<< + * """Check if a player has any valid moves.""" + * cdef PlayerState player = self.players[player_idx] +*/ + +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_13has_valid_moves(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static int __pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame_has_valid_moves(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, int __pyx_v_player_idx, int __pyx_skip_dispatch) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_player = 0; + PyObject *__pyx_v_available_piece_ids = 0; + int __pyx_v_piece_id; + int __pyx_v_action_idx; + PyObject *__pyx_v_name = NULL; + 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; + PyObject *__pyx_t_5 = NULL; + size_t __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_t_12; + PyObject *(*__pyx_t_13)(PyObject *); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("has_valid_moves", 0); + /* Check if called by wrapper */ + if (unlikely(__pyx_skip_dispatch)) ; + /* Check if overridden in Python */ + else if ( + #if !CYTHON_USE_TYPE_SLOTS + unlikely(Py_TYPE(((PyObject *)__pyx_v_self)) != __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame && + __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), Py_TPFLAGS_HAVE_GC)) + #else + unlikely(Py_TYPE(((PyObject *)__pyx_v_self))->tp_dictoffset != 0 || __Pyx_PyType_HasFeature(Py_TYPE(((PyObject *)__pyx_v_self)), (Py_TPFLAGS_IS_ABSTRACT | Py_TPFLAGS_HEAPTYPE))) + #endif + ) { + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + static PY_UINT64_T __pyx_tp_dict_version = __PYX_DICT_VERSION_INIT, __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; + if (unlikely(!__Pyx_object_dict_version_matches(((PyObject *)__pyx_v_self), __pyx_tp_dict_version, __pyx_obj_dict_version))) { + PY_UINT64_T __pyx_typedict_guard = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); + #endif + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_has_valid_moves); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!__Pyx_IsSameCFunction(__pyx_t_1, (void(*)(void)) __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_13has_valid_moves)) { + __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = __pyx_t_1; + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_player_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_7 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_7 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 668, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_7; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + __pyx_tp_dict_version = __Pyx_get_tp_dict_version(((PyObject *)__pyx_v_self)); + __pyx_obj_dict_version = __Pyx_get_object_dict_version(((PyObject *)__pyx_v_self)); + if (unlikely(__pyx_typedict_guard != __pyx_tp_dict_version)) { + __pyx_tp_dict_version = __pyx_obj_dict_version = __PYX_DICT_VERSION_INIT; + } + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + #if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_PYTYPE_LOOKUP && CYTHON_USE_TYPE_SLOTS + } + #endif + } + + /* "blokus_gym/core/blokus_cython.pyx":670 + * cpdef bint has_valid_moves(self, int player_idx): + * """Check if a player has any valid moves.""" + * cdef PlayerState player = self.players[player_idx] # <<<<<<<<<<<<<< + * cdef list available_piece_ids = [] + * cdef int piece_id, action_idx +*/ + if (unlikely(__pyx_v_self->players == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 670, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_self->players, __pyx_v_player_idx, int, 1, __Pyx_PyLong_From_int, 1, 1, 1, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 670, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState))))) __PYX_ERR(0, 670, __pyx_L1_error) + __pyx_v_player = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":671 + * """Check if a player has any valid moves.""" + * cdef PlayerState player = self.players[player_idx] + * cdef list available_piece_ids = [] # <<<<<<<<<<<<<< + * cdef int piece_id, action_idx + * +*/ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 671, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_available_piece_ids = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":675 + * + * # Build available_piece_ids list + * for name in player.available_pieces: # <<<<<<<<<<<<<< + * available_piece_ids.append(self.piece_set.get_piece_id(name)) + * +*/ + __pyx_t_8 = 0; + __pyx_t_2 = __Pyx_set_iterator(__pyx_v_player->available_pieces, 1, (&__pyx_t_9), (&__pyx_t_10)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 675, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_1); + __pyx_t_1 = __pyx_t_2; + __pyx_t_2 = 0; + while (1) { + __pyx_t_11 = __Pyx_set_iter_next(__pyx_t_1, __pyx_t_9, &__pyx_t_8, &__pyx_t_2, __pyx_t_10); + if (unlikely(__pyx_t_11 == 0)) break; + if (unlikely(__pyx_t_11 == -1)) __PYX_ERR(0, 675, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_name, __pyx_t_2); + __pyx_t_2 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":676 + * # Build available_piece_ids list + * for name in player.available_pieces: + * available_piece_ids.append(self.piece_set.get_piece_id(name)) # <<<<<<<<<<<<<< + * + * if not player.can_move: +*/ + __pyx_t_4 = ((PyObject *)__pyx_v_self->piece_set); + __Pyx_INCREF(__pyx_t_4); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_v_name}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get_piece_id, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 676, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_12 = __Pyx_PyList_Append(__pyx_v_available_piece_ids, __pyx_t_2); if (unlikely(__pyx_t_12 == ((int)-1))) __PYX_ERR(0, 676, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":678 + * available_piece_ids.append(self.piece_set.get_piece_id(name)) + * + * if not player.can_move: # <<<<<<<<<<<<<< + * return False + * +*/ + __pyx_t_7 = (!__pyx_v_player->can_move); + if (__pyx_t_7) { + + /* "blokus_gym/core/blokus_cython.pyx":679 + * + * if not player.can_move: + * return False # <<<<<<<<<<<<<< + * + * for piece_id in available_piece_ids: +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":678 + * available_piece_ids.append(self.piece_set.get_piece_id(name)) + * + * if not player.can_move: # <<<<<<<<<<<<<< + * return False + * +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":681 + * return False + * + * for piece_id in available_piece_ids: # <<<<<<<<<<<<<< + * for action_idx in self._actions_by_piece[piece_id]: + * if self.valid_move(player_idx, self._action_moves[action_idx]): +*/ + __pyx_t_1 = __pyx_v_available_piece_ids; __Pyx_INCREF(__pyx_t_1); + __pyx_t_9 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 681, __pyx_L1_error) + #endif + if (__pyx_t_9 >= __pyx_temp) break; + } + __pyx_t_2 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_1, __pyx_t_9, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_9; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 681, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyLong_As_int(__pyx_t_2); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 681, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_piece_id = __pyx_t_10; + + /* "blokus_gym/core/blokus_cython.pyx":682 + * + * for piece_id in available_piece_ids: + * for action_idx in self._actions_by_piece[piece_id]: # <<<<<<<<<<<<<< + * if self.valid_move(player_idx, self._action_moves[action_idx]): + * return True +*/ + if (unlikely(__pyx_v_self->_actions_by_piece == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 682, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_GetItemInt_List(__pyx_v_self->_actions_by_piece, __pyx_v_piece_id, int, 1, __Pyx_PyLong_From_int, 1, 1, 1, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(PyList_CheckExact(__pyx_t_2)) || PyTuple_CheckExact(__pyx_t_2)) { + __pyx_t_4 = __pyx_t_2; __Pyx_INCREF(__pyx_t_4); + __pyx_t_8 = 0; + __pyx_t_13 = NULL; + } else { + __pyx_t_8 = -1; __pyx_t_4 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_13 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_4); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 682, __pyx_L1_error) + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + for (;;) { + if (likely(!__pyx_t_13)) { + if (likely(PyList_CheckExact(__pyx_t_4))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_4); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 682, __pyx_L1_error) + #endif + if (__pyx_t_8 >= __pyx_temp) break; + } + __pyx_t_2 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_4, __pyx_t_8, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_8; + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 682, __pyx_L1_error) + #endif + if (__pyx_t_8 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_8)); + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_8); + #endif + ++__pyx_t_8; + } + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 682, __pyx_L1_error) + } else { + __pyx_t_2 = __pyx_t_13(__pyx_t_4); + if (unlikely(!__pyx_t_2)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 682, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_10 = __Pyx_PyLong_As_int(__pyx_t_2); if (unlikely((__pyx_t_10 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 682, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_v_action_idx = __pyx_t_10; + + /* "blokus_gym/core/blokus_cython.pyx":683 + * for piece_id in available_piece_ids: + * for action_idx in self._actions_by_piece[piece_id]: + * if self.valid_move(player_idx, self._action_moves[action_idx]): # <<<<<<<<<<<<<< + * return True + * return False +*/ + if (unlikely(__pyx_v_self->_action_moves == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 683, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_GetItemInt_List(__pyx_v_self->_action_moves, __pyx_v_action_idx, int, 1, __Pyx_PyLong_From_int, 1, 1, 1, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 683, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move))))) __PYX_ERR(0, 683, __pyx_L1_error) + __pyx_t_7 = ((struct __pyx_vtabstruct_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self->__pyx_vtab)->valid_move(__pyx_v_self, __pyx_v_player_idx, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)__pyx_t_2), 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 683, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_7) { + + /* "blokus_gym/core/blokus_cython.pyx":684 + * for action_idx in self._actions_by_piece[piece_id]: + * if self.valid_move(player_idx, self._action_moves[action_idx]): + * return True # <<<<<<<<<<<<<< + * return False + * +*/ + __pyx_r = 1; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":683 + * for piece_id in available_piece_ids: + * for action_idx in self._actions_by_piece[piece_id]: + * if self.valid_move(player_idx, self._action_moves[action_idx]): # <<<<<<<<<<<<<< + * return True + * return False +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":682 + * + * for piece_id in available_piece_ids: + * for action_idx in self._actions_by_piece[piece_id]: # <<<<<<<<<<<<<< + * if self.valid_move(player_idx, self._action_moves[action_idx]): + * return True +*/ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":681 + * return False + * + * for piece_id in available_piece_ids: # <<<<<<<<<<<<<< + * for action_idx in self._actions_by_piece[piece_id]: + * if self.valid_move(player_idx, self._action_moves[action_idx]): +*/ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":685 + * if self.valid_move(player_idx, self._action_moves[action_idx]): + * return True + * return False # <<<<<<<<<<<<<< + * + * def apply_move(self, int player_idx, Move move) -> None: +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":668 + * return mask + * + * cpdef bint has_valid_moves(self, int player_idx): # <<<<<<<<<<<<<< + * """Check if a player has any valid moves.""" + * cdef PlayerState player = self.players[player_idx] +*/ + + /* 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_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.has_valid_moves", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_player); + __Pyx_XDECREF(__pyx_v_available_piece_ids); + __Pyx_XDECREF(__pyx_v_name); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_13has_valid_moves(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_12has_valid_moves, "Check if a player has any valid moves."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_13has_valid_moves = {"has_valid_moves", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_13has_valid_moves, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_12has_valid_moves}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_13has_valid_moves(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + int __pyx_v_player_idx; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("has_valid_moves (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_player_idx,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 668, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 668, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "has_valid_moves", 0) < (0)) __PYX_ERR(0, 668, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("has_valid_moves", 1, 1, 1, i); __PYX_ERR(0, 668, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 668, __pyx_L3_error) + } + __pyx_v_player_idx = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_player_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 668, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("has_valid_moves", 1, 1, 1, __pyx_nargs); __PYX_ERR(0, 668, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.has_valid_moves", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_12has_valid_moves(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), __pyx_v_player_idx); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_12has_valid_moves(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, int __pyx_v_player_idx) { + 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("has_valid_moves", 0); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame_has_valid_moves(__pyx_v_self, __pyx_v_player_idx, 1); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 668, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.has_valid_moves", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":687 + * return False + * + * def apply_move(self, int player_idx, Move move) -> None: # <<<<<<<<<<<<<< + * """Apply a move to the game state. Does not validate.""" + * cdef PlayerState player = self.players[player_idx] +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_15apply_move(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_14apply_move, "Apply a move to the game state. Does not validate."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_15apply_move = {"apply_move", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_15apply_move, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_14apply_move}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_15apply_move(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + int __pyx_v_player_idx; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_move = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("apply_move (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_player_idx,&__pyx_mstate_global->__pyx_n_u_move,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 687, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 687, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 687, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "apply_move", 0) < (0)) __PYX_ERR(0, 687, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("apply_move", 1, 2, 2, i); __PYX_ERR(0, 687, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 687, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 687, __pyx_L3_error) + } + __pyx_v_player_idx = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_player_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 687, __pyx_L3_error) + __pyx_v_move = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)values[1]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("apply_move", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 687, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.apply_move", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_move), __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move, 1, "move", 0))) __PYX_ERR(0, 687, __pyx_L1_error) + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_14apply_move(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), __pyx_v_player_idx, __pyx_v_move); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_14apply_move(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, int __pyx_v_player_idx, struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_move) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_player = 0; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v_piece = 0; + PyObject *__pyx_v_placed_squares = 0; + int __pyx_v_x; + int __pyx_v_y; + PyObject *__pyx_v_placed_corners = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_t_7; + Py_ssize_t __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *(*__pyx_t_11)(PyObject *); + int __pyx_t_12; + int __pyx_t_13; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("apply_move", 0); + + /* "blokus_gym/core/blokus_cython.pyx":689 + * def apply_move(self, int player_idx, Move move) -> None: + * """Apply a move to the game state. Does not validate.""" + * cdef PlayerState player = self.players[player_idx] # <<<<<<<<<<<<<< + * cdef Piece piece = self.piece_set.get_piece(move.piece_id) + * cdef list placed_squares = self._get_placed_squares(move) +*/ + if (unlikely(__pyx_v_self->players == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 689, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_self->players, __pyx_v_player_idx, int, 1, __Pyx_PyLong_From_int, 1, 1, 1, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 689, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState))))) __PYX_ERR(0, 689, __pyx_L1_error) + __pyx_v_player = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":690 + * """Apply a move to the game state. Does not validate.""" + * cdef PlayerState player = self.players[player_idx] + * cdef Piece piece = self.piece_set.get_piece(move.piece_id) # <<<<<<<<<<<<<< + * cdef list placed_squares = self._get_placed_squares(move) + * cdef int x, y +*/ + __pyx_t_2 = ((PyObject *)__pyx_v_self->piece_set); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_move->piece_id); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 690, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_get_piece, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 690, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece))))) __PYX_ERR(0, 690, __pyx_L1_error) + __pyx_v_piece = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":691 + * cdef PlayerState player = self.players[player_idx] + * cdef Piece piece = self.piece_set.get_piece(move.piece_id) + * cdef list placed_squares = self._get_placed_squares(move) # <<<<<<<<<<<<<< + * cdef int x, y + * +*/ + __pyx_t_1 = ((struct __pyx_vtabstruct_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self->__pyx_vtab)->_get_placed_squares(__pyx_v_self, __pyx_v_move); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_placed_squares = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":695 + * + * # Place the piece + * self.board.place(player_idx + 1, placed_squares) # <<<<<<<<<<<<<< + * + * # Update player state +*/ + __pyx_t_3 = __pyx_v_self->board; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyLong_From_long((__pyx_v_player_idx + 1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 695, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_2, __pyx_v_placed_squares}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_place, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 695, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":698 + * + * # Update player state + * player.available_pieces.discard(piece.name) # <<<<<<<<<<<<<< + * player.score += piece.size + * +*/ + if (unlikely(__pyx_v_player->available_pieces == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "discard"); + __PYX_ERR(0, 698, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_piece->name; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PySet_Discard(__pyx_v_player->available_pieces, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 698, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":699 + * # Update player state + * player.available_pieces.discard(piece.name) + * player.score += piece.size # <<<<<<<<<<<<<< + * + * # Update corners +*/ + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_player->score); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_piece), __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_InPlaceAdd(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 699, __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_t_6 = __Pyx_PyLong_As_int(__pyx_t_3); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 699, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_player->score = __pyx_t_6; + + /* "blokus_gym/core/blokus_cython.pyx":702 + * + * # Update corners + * if not player.has_started: # <<<<<<<<<<<<<< + * player.has_started = True + * player.corners = set() +*/ + __pyx_t_7 = (!__pyx_v_player->has_started); + if (__pyx_t_7) { + + /* "blokus_gym/core/blokus_cython.pyx":703 + * # Update corners + * if not player.has_started: + * player.has_started = True # <<<<<<<<<<<<<< + * player.corners = set() + * +*/ + __pyx_v_player->has_started = 1; + + /* "blokus_gym/core/blokus_cython.pyx":704 + * if not player.has_started: + * player.has_started = True + * player.corners = set() # <<<<<<<<<<<<<< + * + * # Add new corners +*/ + __pyx_t_3 = PySet_New(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 704, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __Pyx_GOTREF(__pyx_v_player->corners); + __Pyx_DECREF(__pyx_v_player->corners); + __pyx_v_player->corners = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":702 + * + * # Update corners + * if not player.has_started: # <<<<<<<<<<<<<< + * player.has_started = True + * player.corners = set() +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":707 + * + * # Add new corners + * cdef list placed_corners = self._get_placed_corners(move) # <<<<<<<<<<<<<< + * for x, y in placed_corners: + * if self.board.in_bounds(x, y) and self.board.is_empty(x, y): +*/ + __pyx_t_3 = ((struct __pyx_vtabstruct_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self->__pyx_vtab)->_get_placed_corners(__pyx_v_self, __pyx_v_move); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 707, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_placed_corners = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":708 + * # Add new corners + * cdef list placed_corners = self._get_placed_corners(move) + * for x, y in placed_corners: # <<<<<<<<<<<<<< + * if self.board.in_bounds(x, y) and self.board.is_empty(x, y): + * player.corners.add((x, y)) +*/ + if (unlikely(__pyx_v_placed_corners == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 708, __pyx_L1_error) + } + __pyx_t_3 = __pyx_v_placed_corners; __Pyx_INCREF(__pyx_t_3); + __pyx_t_8 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 708, __pyx_L1_error) + #endif + if (__pyx_t_8 >= __pyx_temp) break; + } + __pyx_t_2 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_3, __pyx_t_8, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_8; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if ((likely(PyTuple_CheckExact(__pyx_t_2))) || (PyList_CheckExact(__pyx_t_2))) { + 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(0, 708, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + if (likely(PyTuple_CheckExact(sequence))) { + __pyx_t_1 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_9 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_9); + } else { + __pyx_t_1 = __Pyx_PyList_GET_ITEM_REF(sequence, 0, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 708, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_PyList_GET_ITEM_REF(sequence, 1, __Pyx_ReferenceSharing_SharedReference); + if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 708, __pyx_L1_error) + __Pyx_XGOTREF(__pyx_t_9); + } + #else + __pyx_t_1 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #endif + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + Py_ssize_t index = -1; + __pyx_t_10 = PyObject_GetIter(__pyx_t_2); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 708, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_11 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_10); + index = 0; __pyx_t_1 = __pyx_t_11(__pyx_t_10); if (unlikely(!__pyx_t_1)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_1); + index = 1; __pyx_t_9 = __pyx_t_11(__pyx_t_10); if (unlikely(!__pyx_t_9)) goto __pyx_L6_unpacking_failed; + __Pyx_GOTREF(__pyx_t_9); + if (__Pyx_IternextUnpackEndCheck(__pyx_t_11(__pyx_t_10), 2) < (0)) __PYX_ERR(0, 708, __pyx_L1_error) + __pyx_t_11 = NULL; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + goto __pyx_L7_unpacking_done; + __pyx_L6_unpacking_failed:; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_11 = NULL; + if (__Pyx_IterFinish() == 0) __Pyx_RaiseNeedMoreValuesError(index); + __PYX_ERR(0, 708, __pyx_L1_error) + __pyx_L7_unpacking_done:; + } + __pyx_t_6 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_6 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 708, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_12 = __Pyx_PyLong_As_int(__pyx_t_9); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 708, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_v_x = __pyx_t_6; + __pyx_v_y = __pyx_t_12; + + /* "blokus_gym/core/blokus_cython.pyx":709 + * cdef list placed_corners = self._get_placed_corners(move) + * for x, y in placed_corners: + * if self.board.in_bounds(x, y) and self.board.is_empty(x, y): # <<<<<<<<<<<<<< + * player.corners.add((x, y)) + * +*/ + __pyx_t_9 = __pyx_v_self->board; + __Pyx_INCREF(__pyx_t_9); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 709, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_10 = __Pyx_PyLong_From_int(__pyx_v_y); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 709, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_9, __pyx_t_1, __pyx_t_10}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_in_bounds, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 709, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 709, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_13) { + } else { + __pyx_t_7 = __pyx_t_13; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_10 = __pyx_v_self->board; + __Pyx_INCREF(__pyx_t_10); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_x); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 709, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = __Pyx_PyLong_From_int(__pyx_v_y); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 709, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_10, __pyx_t_1, __pyx_t_9}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_is_empty, __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 709, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_13 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_13 < 0))) __PYX_ERR(0, 709, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_7 = __pyx_t_13; + __pyx_L9_bool_binop_done:; + if (__pyx_t_7) { + + /* "blokus_gym/core/blokus_cython.pyx":710 + * for x, y in placed_corners: + * if self.board.in_bounds(x, y) and self.board.is_empty(x, y): + * player.corners.add((x, y)) # <<<<<<<<<<<<<< + * + * # Check game over +*/ + if (unlikely(__pyx_v_player->corners == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "add"); + __PYX_ERR(0, 710, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_x); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 710, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_9 = __Pyx_PyLong_From_int(__pyx_v_y); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 710, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 710, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 710, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_9); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_9) != (0)) __PYX_ERR(0, 710, __pyx_L1_error); + __pyx_t_2 = 0; + __pyx_t_9 = 0; + __pyx_t_5 = PySet_Add(__pyx_v_player->corners, __pyx_t_1); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(0, 710, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":709 + * cdef list placed_corners = self._get_placed_corners(move) + * for x, y in placed_corners: + * if self.board.in_bounds(x, y) and self.board.is_empty(x, y): # <<<<<<<<<<<<<< + * player.corners.add((x, y)) + * +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":708 + * # Add new corners + * cdef list placed_corners = self._get_placed_corners(move) + * for x, y in placed_corners: # <<<<<<<<<<<<<< + * if self.board.in_bounds(x, y) and self.board.is_empty(x, y): + * player.corners.add((x, y)) +*/ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":713 + * + * # Check game over + * self._check_game_over() # <<<<<<<<<<<<<< + * + * def play_move(self, int player_idx, int action) -> bint: +*/ + __pyx_t_1 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_check_game_over, __pyx_callargs+__pyx_t_4, (1-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 713, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":687 + * return False + * + * def apply_move(self, int player_idx, Move move) -> None: # <<<<<<<<<<<<<< + * """Apply a move to the game state. Does not validate.""" + * cdef PlayerState player = self.players[player_idx] +*/ + + /* 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_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.apply_move", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_player); + __Pyx_XDECREF((PyObject *)__pyx_v_piece); + __Pyx_XDECREF(__pyx_v_placed_squares); + __Pyx_XDECREF(__pyx_v_placed_corners); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":715 + * self._check_game_over() + * + * def play_move(self, int player_idx, int action) -> bint: # <<<<<<<<<<<<<< + * """Play an action for the given player. Validates first.""" + * cdef Move move = self._action_moves[action] +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17play_move(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_16play_move, "Play an action for the given player. Validates first."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_17play_move = {"play_move", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17play_move, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_16play_move}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17play_move(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + int __pyx_v_player_idx; + int __pyx_v_action; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[2] = {0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("play_move (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_player_idx,&__pyx_mstate_global->__pyx_n_u_action,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(0, 715, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 715, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 715, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "play_move", 0) < (0)) __PYX_ERR(0, 715, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("play_move", 1, 2, 2, i); __PYX_ERR(0, 715, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 2)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 715, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 715, __pyx_L3_error) + } + __pyx_v_player_idx = __Pyx_PyLong_As_int(values[0]); if (unlikely((__pyx_v_player_idx == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 715, __pyx_L3_error) + __pyx_v_action = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_action == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 715, __pyx_L3_error) + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("play_move", 1, 2, 2, __pyx_nargs); __PYX_ERR(0, 715, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.play_move", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_16play_move(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), __pyx_v_player_idx, __pyx_v_action); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_16play_move(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, int __pyx_v_player_idx, int __pyx_v_action) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v_move = 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; + size_t __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("play_move", 0); + + /* "blokus_gym/core/blokus_cython.pyx":717 + * def play_move(self, int player_idx, int action) -> bint: + * """Play an action for the given player. Validates first.""" + * cdef Move move = self._action_moves[action] # <<<<<<<<<<<<<< + * + * if not self.valid_move(player_idx, move): +*/ + if (unlikely(__pyx_v_self->_action_moves == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 717, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_GetItemInt_List(__pyx_v_self->_action_moves, __pyx_v_action, int, 1, __Pyx_PyLong_From_int, 1, 1, 1, 1, __Pyx_ReferenceSharing_SharedReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move))))) __PYX_ERR(0, 717, __pyx_L1_error) + __pyx_v_move = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":719 + * cdef Move move = self._action_moves[action] + * + * if not self.valid_move(player_idx, move): # <<<<<<<<<<<<<< + * return False + * +*/ + __pyx_t_2 = ((struct __pyx_vtabstruct_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self->__pyx_vtab)->valid_move(__pyx_v_self, __pyx_v_player_idx, __pyx_v_move, 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 719, __pyx_L1_error) + __pyx_t_3 = (!__pyx_t_2); + if (__pyx_t_3) { + + /* "blokus_gym/core/blokus_cython.pyx":720 + * + * if not self.valid_move(player_idx, move): + * return False # <<<<<<<<<<<<<< + * + * self.apply_move(player_idx, move) +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":719 + * cdef Move move = self._action_moves[action] + * + * if not self.valid_move(player_idx, move): # <<<<<<<<<<<<<< + * return False + * +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":722 + * return False + * + * self.apply_move(player_idx, move) # <<<<<<<<<<<<<< + * return True + * +*/ + __pyx_t_4 = ((PyObject *)__pyx_v_self); + __Pyx_INCREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_player_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 722, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_5, ((PyObject *)__pyx_v_move)}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_apply_move, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 722, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":723 + * + * self.apply_move(player_idx, move) + * return True # <<<<<<<<<<<<<< + * + * def next_player(self): +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":715 + * self._check_game_over() + * + * def play_move(self, int player_idx, int action) -> bint: # <<<<<<<<<<<<<< + * """Play an action for the given player. Validates first.""" + * cdef Move move = self._action_moves[action] +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.play_move", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_move); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":725 + * return True + * + * def next_player(self): # <<<<<<<<<<<<<< + * """Advance to the next player who can still move. + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_19next_player(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_18next_player, "Advance to the next player who can still move.\n \n If no players can move, the game is over.\n "); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_19next_player = {"next_player", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_19next_player, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_18next_player}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_19next_player(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("next_player (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("next_player", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("next_player", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_18next_player(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_18next_player(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + PyObject *__pyx_v_offset = NULL; + PyObject *__pyx_v_next_idx = NULL; + PyObject *__pyx_v_next_player = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + PyObject *(*__pyx_t_5)(PyObject *); + PyObject *__pyx_t_6 = NULL; + 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; + __Pyx_RefNannySetupContext("next_player", 0); + + /* "blokus_gym/core/blokus_cython.pyx":730 + * If no players can move, the game is over. + * """ + * if self.game_over: # <<<<<<<<<<<<<< + * return self.current_player + * +*/ + if (__pyx_v_self->game_over) { + + /* "blokus_gym/core/blokus_cython.pyx":731 + * """ + * if self.game_over: + * return self.current_player # <<<<<<<<<<<<<< + * + * for offset in range(1, self.num_players + 1): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->current_player); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 731, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":730 + * If no players can move, the game is over. + * """ + * if self.game_over: # <<<<<<<<<<<<<< + * return self.current_player + * +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":733 + * return self.current_player + * + * for offset in range(1, self.num_players + 1): # <<<<<<<<<<<<<< + * next_idx = (self.current_player + offset) % self.num_players + * next_player = self.players[next_idx] +*/ + __pyx_t_2 = NULL; + __pyx_t_3 = __Pyx_PyLong_From_long((__pyx_v_self->num_players + 1)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 733, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_mstate_global->__pyx_int_1, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(&PyRange_Type), __pyx_callargs+__pyx_t_4, (3-__pyx_t_4) | (__pyx_t_4*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 733, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_3 = PyObject_GetIter(__pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 733, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 733, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + for (;;) { + { + __pyx_t_1 = __pyx_t_5(__pyx_t_3); + if (unlikely(!__pyx_t_1)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 733, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_offset, __pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":734 + * + * for offset in range(1, self.num_players + 1): + * next_idx = (self.current_player + offset) % self.num_players # <<<<<<<<<<<<<< + * next_player = self.players[next_idx] + * if next_player.can_move and self.has_valid_moves(next_idx): +*/ + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->current_player); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 734, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyNumber_Add(__pyx_t_1, __pyx_v_offset); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 734, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->num_players); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 734, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = PyNumber_Remainder(__pyx_t_2, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 734, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF_SET(__pyx_v_next_idx, __pyx_t_6); + __pyx_t_6 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":735 + * for offset in range(1, self.num_players + 1): + * next_idx = (self.current_player + offset) % self.num_players + * next_player = self.players[next_idx] # <<<<<<<<<<<<<< + * if next_player.can_move and self.has_valid_moves(next_idx): + * self.current_player = next_idx +*/ + if (unlikely(__pyx_v_self->players == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 735, __pyx_L1_error) + } + __pyx_t_6 = __Pyx_PyObject_GetItem(__pyx_v_self->players, __pyx_v_next_idx); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 735, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_XDECREF_SET(__pyx_v_next_player, __pyx_t_6); + __pyx_t_6 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":736 + * next_idx = (self.current_player + offset) % self.num_players + * next_player = self.players[next_idx] + * if next_player.can_move and self.has_valid_moves(next_idx): # <<<<<<<<<<<<<< + * self.current_player = next_idx + * return next_idx +*/ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_next_player, __pyx_mstate_global->__pyx_n_u_can_move); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 736, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_t_6); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(0, 736, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (__pyx_t_8) { + } else { + __pyx_t_7 = __pyx_t_8; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_9 = __Pyx_PyLong_As_int(__pyx_v_next_idx); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 736, __pyx_L1_error) + __pyx_t_8 = ((struct __pyx_vtabstruct_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self->__pyx_vtab)->has_valid_moves(__pyx_v_self, __pyx_t_9, 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 736, __pyx_L1_error) + __pyx_t_7 = __pyx_t_8; + __pyx_L7_bool_binop_done:; + if (__pyx_t_7) { + + /* "blokus_gym/core/blokus_cython.pyx":737 + * next_player = self.players[next_idx] + * if next_player.can_move and self.has_valid_moves(next_idx): + * self.current_player = next_idx # <<<<<<<<<<<<<< + * return next_idx + * +*/ + __pyx_t_9 = __Pyx_PyLong_As_int(__pyx_v_next_idx); if (unlikely((__pyx_t_9 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 737, __pyx_L1_error) + __pyx_v_self->current_player = __pyx_t_9; + + /* "blokus_gym/core/blokus_cython.pyx":738 + * if next_player.can_move and self.has_valid_moves(next_idx): + * self.current_player = next_idx + * return next_idx # <<<<<<<<<<<<<< + * + * # No one can move game over +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_next_idx); + __pyx_r = __pyx_v_next_idx; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":736 + * next_idx = (self.current_player + offset) % self.num_players + * next_player = self.players[next_idx] + * if next_player.can_move and self.has_valid_moves(next_idx): # <<<<<<<<<<<<<< + * self.current_player = next_idx + * return next_idx +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":733 + * return self.current_player + * + * for offset in range(1, self.num_players + 1): # <<<<<<<<<<<<<< + * next_idx = (self.current_player + offset) % self.num_players + * next_player = self.players[next_idx] +*/ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":741 + * + * # No one can move game over + * self.game_over = True # <<<<<<<<<<<<<< + * return self.current_player + * +*/ + __pyx_v_self->game_over = 1; + + /* "blokus_gym/core/blokus_cython.pyx":742 + * # No one can move game over + * self.game_over = True + * return self.current_player # <<<<<<<<<<<<<< + * + * def _check_game_over(self) -> None: +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_self->current_player); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":725 + * return True + * + * def next_player(self): # <<<<<<<<<<<<<< + * """Advance to the next player who can still move. + * +*/ + + /* 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_6); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.next_player", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_offset); + __Pyx_XDECREF(__pyx_v_next_idx); + __Pyx_XDECREF(__pyx_v_next_player); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":744 + * return self.current_player + * + * def _check_game_over(self) -> None: # <<<<<<<<<<<<<< + * """Check if the game is over.""" + * cdef PlayerState player +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_21_check_game_over(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_20_check_game_over, "Check if the game is over."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_21_check_game_over = {"_check_game_over", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_21_check_game_over, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_20_check_game_over}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_21_check_game_over(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_check_game_over (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("_check_game_over", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("_check_game_over", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_20_check_game_over(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_10BlokusGame_16_check_game_over_2generator5(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ + +/* "blokus_gym/core/blokus_cython.pyx":754 + * + * # Game ends if all players can't move + * if all(not p.can_move for p in self.players): # <<<<<<<<<<<<<< + * self.game_over = True + * elif all(p.has_started and not p.available_pieces for p in self.players): +*/ + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_16_check_game_over_genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 754, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_10blokus_gym_4core_13blokus_cython_10BlokusGame_16_check_game_over_2generator5, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[5]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_check_game_over_locals_genexpr, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython); if (unlikely(!gen)) __PYX_ERR(0, 754, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame._check_game_over.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF((PyObject *)__pyx_cur_scope); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_10BlokusGame_16_check_game_over_2generator5(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr *__pyx_cur_scope = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 754, __pyx_L1_error) + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 754, __pyx_L1_error) } + if (unlikely(__pyx_cur_scope->__pyx_genexpr_arg_0 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 754, __pyx_L1_error) + } + __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 754, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + __pyx_t_3 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_1, __pyx_t_2, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 754, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_p); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_p, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_p, __pyx_mstate_global->__pyx_n_u_can_move); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 754, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(0, 754, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_5 = (!(!__pyx_t_4)); + if (__pyx_t_5) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + goto __pyx_L0; + } + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + if (__Pyx_PyErr_Occurred()) { + __Pyx_Generator_Replace_StopIteration(0); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +static PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_10BlokusGame_16_check_game_over_5generator6(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value); /* proto */ + +/* "blokus_gym/core/blokus_cython.pyx":756 + * if all(not p.can_move for p in self.players): + * self.game_over = True + * elif all(p.has_started and not p.available_pieces for p in self.players): # <<<<<<<<<<<<<< + * # All pieces played + * self.game_over = True +*/ + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_16_check_game_over_3genexpr(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_genexpr_arg_0) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr *__pyx_cur_scope; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("genexpr", 0); + __pyx_cur_scope = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (unlikely(!__pyx_cur_scope)) { + __pyx_cur_scope = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr *)Py_None); + __Pyx_INCREF(Py_None); + __PYX_ERR(0, 756, __pyx_L1_error) + } else { + __Pyx_GOTREF((PyObject *)__pyx_cur_scope); + } + __pyx_cur_scope->__pyx_genexpr_arg_0 = __pyx_genexpr_arg_0; + __Pyx_INCREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + __Pyx_GIVEREF(__pyx_cur_scope->__pyx_genexpr_arg_0); + { + __pyx_CoroutineObject *gen = __Pyx_Generator_New((__pyx_coroutine_body_t) __pyx_gb_10blokus_gym_4core_13blokus_cython_10BlokusGame_16_check_game_over_5generator6, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[6]), (PyObject *) __pyx_cur_scope, __pyx_mstate_global->__pyx_n_u_genexpr, __pyx_mstate_global->__pyx_n_u_check_game_over_locals_genexpr, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython); if (unlikely(!gen)) __PYX_ERR(0, 756, __pyx_L1_error) + __Pyx_DECREF(__pyx_cur_scope); + __Pyx_RefNannyFinishContext(); + return (PyObject *) gen; + } + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame._check_game_over.genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_DECREF((PyObject *)__pyx_cur_scope); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_10BlokusGame_16_check_game_over_5generator6(__pyx_CoroutineObject *__pyx_generator, CYTHON_UNUSED PyThreadState *__pyx_tstate, PyObject *__pyx_sent_value) /* generator body */ +{ + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr *__pyx_cur_scope = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr *)__pyx_generator->closure); + PyObject *__pyx_r = NULL; + PyObject *__pyx_t_1 = NULL; + Py_ssize_t __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_RefNannyDeclarations + __Pyx_RefNannySetupContext("genexpr", 0); + switch (__pyx_generator->resume_label) { + case 0: goto __pyx_L3_first_run; + default: /* CPython raises the right error here */ + __Pyx_RefNannyFinishContext(); + return NULL; + } + __pyx_L3_first_run:; + if (unlikely(!__pyx_sent_value)) __PYX_ERR(0, 756, __pyx_L1_error) + if (unlikely(!__pyx_cur_scope->__pyx_genexpr_arg_0)) { __Pyx_RaiseUnboundLocalError(".0"); __PYX_ERR(0, 756, __pyx_L1_error) } + if (unlikely(__pyx_cur_scope->__pyx_genexpr_arg_0 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 756, __pyx_L1_error) + } + __pyx_t_1 = __pyx_cur_scope->__pyx_genexpr_arg_0; __Pyx_INCREF(__pyx_t_1); + __pyx_t_2 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 756, __pyx_L1_error) + #endif + if (__pyx_t_2 >= __pyx_temp) break; + } + __pyx_t_3 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_1, __pyx_t_2, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_2; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 756, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_cur_scope->__pyx_v_p); + __Pyx_XDECREF_SET(__pyx_cur_scope->__pyx_v_p, __pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_p, __pyx_mstate_global->__pyx_n_u_has_started); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 756, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 756, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_5) { + } else { + __pyx_t_4 = __pyx_t_5; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_cur_scope->__pyx_v_p, __pyx_mstate_global->__pyx_n_u_available_pieces); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 756, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_5 < 0))) __PYX_ERR(0, 756, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = (!__pyx_t_5); + __pyx_t_4 = __pyx_t_6; + __pyx_L7_bool_binop_done:; + __pyx_t_6 = (!__pyx_t_4); + if (__pyx_t_6) { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_False); + __pyx_r = Py_False; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L0; + } + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(Py_True); + __pyx_r = Py_True; + goto __pyx_L0; + } + CYTHON_MAYBE_UNUSED_VAR(__pyx_cur_scope); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + if (__Pyx_PyErr_Occurred()) { + __Pyx_Generator_Replace_StopIteration(0); + __Pyx_AddTraceback("genexpr", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + #if !CYTHON_USE_EXC_INFO_STACK + __Pyx_Coroutine_ResetAndClearException(__pyx_generator); + #endif + __pyx_generator->resume_label = -1; + __Pyx_Coroutine_clear((PyObject*)__pyx_generator); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":744 + * return self.current_player + * + * def _check_game_over(self) -> None: # <<<<<<<<<<<<<< + * """Check if the game is over.""" + * cdef PlayerState player +*/ + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_20_check_game_over(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v_player = 0; + int __pyx_v_player_idx; + PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_10BlokusGame_16_check_game_over_2generator5 = 0; + PyObject *__pyx_gb_10blokus_gym_4core_13blokus_cython_10BlokusGame_16_check_game_over_5generator6 = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_check_game_over", 0); + + /* "blokus_gym/core/blokus_cython.pyx":749 + * cdef int player_idx + * + * for player_idx, player in enumerate(self.players): # <<<<<<<<<<<<<< + * if not self.has_valid_moves(player_idx): + * player.can_move = False +*/ + __pyx_t_1 = 0; + __pyx_t_2 = __pyx_v_self->players; __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 749, __pyx_L1_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + __pyx_t_4 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_2, __pyx_t_3, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_3; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 749, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (!(likely(((__pyx_t_4) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_4, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState))))) __PYX_ERR(0, 749, __pyx_L1_error) + __Pyx_XDECREF_SET(__pyx_v_player, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_t_4)); + __pyx_t_4 = 0; + __pyx_v_player_idx = __pyx_t_1; + __pyx_t_1 = (__pyx_t_1 + 1); + + /* "blokus_gym/core/blokus_cython.pyx":750 + * + * for player_idx, player in enumerate(self.players): + * if not self.has_valid_moves(player_idx): # <<<<<<<<<<<<<< + * player.can_move = False + * +*/ + __pyx_t_5 = ((struct __pyx_vtabstruct_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self->__pyx_vtab)->has_valid_moves(__pyx_v_self, __pyx_v_player_idx, 0); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 750, __pyx_L1_error) + __pyx_t_6 = (!__pyx_t_5); + if (__pyx_t_6) { + + /* "blokus_gym/core/blokus_cython.pyx":751 + * for player_idx, player in enumerate(self.players): + * if not self.has_valid_moves(player_idx): + * player.can_move = False # <<<<<<<<<<<<<< + * + * # Game ends if all players can't move +*/ + __pyx_v_player->can_move = 0; + + /* "blokus_gym/core/blokus_cython.pyx":750 + * + * for player_idx, player in enumerate(self.players): + * if not self.has_valid_moves(player_idx): # <<<<<<<<<<<<<< + * player.can_move = False + * +*/ + } + + /* "blokus_gym/core/blokus_cython.pyx":749 + * cdef int player_idx + * + * for player_idx, player in enumerate(self.players): # <<<<<<<<<<<<<< + * if not self.has_valid_moves(player_idx): + * player.can_move = False +*/ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":754 + * + * # Game ends if all players can't move + * if all(not p.can_move for p in self.players): # <<<<<<<<<<<<<< + * self.game_over = True + * elif all(p.has_started and not p.available_pieces for p in self.players): +*/ + __pyx_t_2 = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_16_check_game_over_genexpr(NULL, __pyx_v_self->players); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 754, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_Generator_GetInlinedResult(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 754, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 754, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_6) { + + /* "blokus_gym/core/blokus_cython.pyx":755 + * # Game ends if all players can't move + * if all(not p.can_move for p in self.players): + * self.game_over = True # <<<<<<<<<<<<<< + * elif all(p.has_started and not p.available_pieces for p in self.players): + * # All pieces played +*/ + __pyx_v_self->game_over = 1; + + /* "blokus_gym/core/blokus_cython.pyx":754 + * + * # Game ends if all players can't move + * if all(not p.can_move for p in self.players): # <<<<<<<<<<<<<< + * self.game_over = True + * elif all(p.has_started and not p.available_pieces for p in self.players): +*/ + goto __pyx_L7; + } + + /* "blokus_gym/core/blokus_cython.pyx":756 + * if all(not p.can_move for p in self.players): + * self.game_over = True + * elif all(p.has_started and not p.available_pieces for p in self.players): # <<<<<<<<<<<<<< + * # All pieces played + * self.game_over = True +*/ + __pyx_t_4 = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_16_check_game_over_3genexpr(NULL, __pyx_v_self->players); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 756, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_Generator_GetInlinedResult(__pyx_t_4); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 756, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = __Pyx_PyObject_IsTrue(__pyx_t_2); if (unlikely((__pyx_t_6 < 0))) __PYX_ERR(0, 756, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (__pyx_t_6) { + + /* "blokus_gym/core/blokus_cython.pyx":758 + * elif all(p.has_started and not p.available_pieces for p in self.players): + * # All pieces played + * self.game_over = True # <<<<<<<<<<<<<< + * + * def get_state(self) -> dict: +*/ + __pyx_v_self->game_over = 1; + + /* "blokus_gym/core/blokus_cython.pyx":756 + * if all(not p.can_move for p in self.players): + * self.game_over = True + * elif all(p.has_started and not p.available_pieces for p in self.players): # <<<<<<<<<<<<<< + * # All pieces played + * self.game_over = True +*/ + } + __pyx_L7:; + + /* "blokus_gym/core/blokus_cython.pyx":744 + * return self.current_player + * + * def _check_game_over(self) -> None: # <<<<<<<<<<<<<< + * """Check if the game is over.""" + * cdef PlayerState player +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame._check_game_over", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_player); + __Pyx_XDECREF(__pyx_gb_10blokus_gym_4core_13blokus_cython_10BlokusGame_16_check_game_over_2generator5); + __Pyx_XDECREF(__pyx_gb_10blokus_gym_4core_13blokus_cython_10BlokusGame_16_check_game_over_5generator6); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":760 + * self.game_over = True + * + * def get_state(self) -> dict: # <<<<<<<<<<<<<< + * """Get the current game state as a dictionary.""" + * return { +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_23get_state(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_22get_state, "Get the current game state as a dictionary."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_23get_state = {"get_state", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_23get_state, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_22get_state}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_23get_state(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("get_state (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("get_state", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("get_state", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_22get_state(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_22get_state(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + PyObject *__pyx_9genexpr11__pyx_v_p = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_state", 0); + + /* "blokus_gym/core/blokus_cython.pyx":762 + * def get_state(self) -> dict: + * """Get the current game state as a dictionary.""" + * return { # <<<<<<<<<<<<<< + * "board_size": self.board_size, + * "num_players": self.num_players, +*/ + __Pyx_XDECREF(__pyx_r); + + /* "blokus_gym/core/blokus_cython.pyx":763 + * """Get the current game state as a dictionary.""" + * return { + * "board_size": self.board_size, # <<<<<<<<<<<<<< + * "num_players": self.num_players, + * "current_player": self.current_player, +*/ + __pyx_t_1 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 763, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->board_size); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 763, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_board_size, __pyx_t_2) < (0)) __PYX_ERR(0, 763, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":764 + * return { + * "board_size": self.board_size, + * "num_players": self.num_players, # <<<<<<<<<<<<<< + * "current_player": self.current_player, + * "rounds": self.rounds, +*/ + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->num_players); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 764, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_num_players, __pyx_t_2) < (0)) __PYX_ERR(0, 763, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":765 + * "board_size": self.board_size, + * "num_players": self.num_players, + * "current_player": self.current_player, # <<<<<<<<<<<<<< + * "rounds": self.rounds, + * "game_over": self.game_over, +*/ + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->current_player); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 765, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_current_player, __pyx_t_2) < (0)) __PYX_ERR(0, 763, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":766 + * "num_players": self.num_players, + * "current_player": self.current_player, + * "rounds": self.rounds, # <<<<<<<<<<<<<< + * "game_over": self.game_over, + * "players": [ +*/ + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_self->rounds); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 766, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rounds, __pyx_t_2) < (0)) __PYX_ERR(0, 763, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":767 + * "current_player": self.current_player, + * "rounds": self.rounds, + * "game_over": self.game_over, # <<<<<<<<<<<<<< + * "players": [ + * { +*/ + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->game_over); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 767, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_game_over, __pyx_t_2) < (0)) __PYX_ERR(0, 763, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + { /* enter inner scope */ + + /* "blokus_gym/core/blokus_cython.pyx":768 + * "rounds": self.rounds, + * "game_over": self.game_over, + * "players": [ # <<<<<<<<<<<<<< + * { + * "idx": p.idx, +*/ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 768, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "blokus_gym/core/blokus_cython.pyx":776 + * "can_move": p.can_move, + * } + * for p in self.players # <<<<<<<<<<<<<< + * ], + * } +*/ + if (unlikely(__pyx_v_self->players == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(0, 776, __pyx_L5_error) + } + __pyx_t_3 = __pyx_v_self->players; __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_3); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 776, __pyx_L5_error) + #endif + if (__pyx_t_4 >= __pyx_temp) break; + } + __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_3, __pyx_t_4, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_4; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 776, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF_SET(__pyx_9genexpr11__pyx_v_p, __pyx_t_5); + __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":770 + * "players": [ + * { + * "idx": p.idx, # <<<<<<<<<<<<<< + * "available_pieces": list(p.available_pieces), + * "score": p.score, +*/ + __pyx_t_5 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 770, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr11__pyx_v_p, __pyx_mstate_global->__pyx_n_u_idx); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 770, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_idx, __pyx_t_6) < (0)) __PYX_ERR(0, 770, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":771 + * { + * "idx": p.idx, + * "available_pieces": list(p.available_pieces), # <<<<<<<<<<<<<< + * "score": p.score, + * "has_started": p.has_started, +*/ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr11__pyx_v_p, __pyx_mstate_global->__pyx_n_u_available_pieces); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 771, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PySequence_ListKeepNew(__pyx_t_6); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 771, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_available_pieces, __pyx_t_7) < (0)) __PYX_ERR(0, 770, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":772 + * "idx": p.idx, + * "available_pieces": list(p.available_pieces), + * "score": p.score, # <<<<<<<<<<<<<< + * "has_started": p.has_started, + * "can_move": p.can_move, +*/ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr11__pyx_v_p, __pyx_mstate_global->__pyx_n_u_score); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 772, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_7); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_score, __pyx_t_7) < (0)) __PYX_ERR(0, 770, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":773 + * "available_pieces": list(p.available_pieces), + * "score": p.score, + * "has_started": p.has_started, # <<<<<<<<<<<<<< + * "can_move": p.can_move, + * } +*/ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr11__pyx_v_p, __pyx_mstate_global->__pyx_n_u_has_started); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 773, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_7); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_has_started, __pyx_t_7) < (0)) __PYX_ERR(0, 770, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":774 + * "score": p.score, + * "has_started": p.has_started, + * "can_move": p.can_move, # <<<<<<<<<<<<<< + * } + * for p in self.players +*/ + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_9genexpr11__pyx_v_p, __pyx_mstate_global->__pyx_n_u_can_move); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 774, __pyx_L5_error) + __Pyx_GOTREF(__pyx_t_7); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_can_move, __pyx_t_7) < (0)) __PYX_ERR(0, 770, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_5))) __PYX_ERR(0, 768, __pyx_L5_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":776 + * "can_move": p.can_move, + * } + * for p in self.players # <<<<<<<<<<<<<< + * ], + * } +*/ + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_9genexpr11__pyx_v_p); __pyx_9genexpr11__pyx_v_p = 0; + goto __pyx_L9_exit_scope; + __pyx_L5_error:; + __Pyx_XDECREF(__pyx_9genexpr11__pyx_v_p); __pyx_9genexpr11__pyx_v_p = 0; + goto __pyx_L1_error; + __pyx_L9_exit_scope:; + } /* exit inner scope */ + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_players, __pyx_t_2) < (0)) __PYX_ERR(0, 763, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":760 + * self.game_over = True + * + * def get_state(self) -> dict: # <<<<<<<<<<<<<< + * """Get the current game state as a dictionary.""" + * return { +*/ + + /* 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_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.get_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_9genexpr11__pyx_v_p); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":780 + * } + * + * def copy(self) -> BlokusGame: # <<<<<<<<<<<<<< + * """Create a deep copy of the game.""" + * cdef BlokusGame new_game = BlokusGame( +*/ + +/* Python wrapper */ +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_25copy(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_24copy, "Create a deep copy of the game."); +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_25copy = {"copy", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_25copy, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_24copy}; +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_25copy(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("copy", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("copy", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_24copy(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_24copy(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_new_game = 0; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_v_p = NULL; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__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; + size_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + int __pyx_t_8; + int __pyx_t_9; + Py_ssize_t __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("copy", 0); + + /* "blokus_gym/core/blokus_cython.pyx":782 + * def copy(self) -> BlokusGame: + * """Create a deep copy of the game.""" + * cdef BlokusGame new_game = BlokusGame( # <<<<<<<<<<<<<< + * board_size=self.board_size, + * pieces=self.piece_set, +*/ + __pyx_t_2 = NULL; + + /* "blokus_gym/core/blokus_cython.pyx":783 + * """Create a deep copy of the game.""" + * cdef BlokusGame new_game = BlokusGame( + * board_size=self.board_size, # <<<<<<<<<<<<<< + * pieces=self.piece_set, + * num_players=self.num_players, +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_self->board_size); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 783, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "blokus_gym/core/blokus_cython.pyx":785 + * board_size=self.board_size, + * pieces=self.piece_set, + * num_players=self.num_players, # <<<<<<<<<<<<<< + * corner_rule=self.corner_rule + * ) +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_self->num_players); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 785, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "blokus_gym/core/blokus_cython.pyx":786 + * pieces=self.piece_set, + * num_players=self.num_players, + * corner_rule=self.corner_rule # <<<<<<<<<<<<<< + * ) + * +*/ + __pyx_t_5 = __Pyx_PyBool_FromLong(__pyx_v_self->corner_rule); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 786, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 4 : 0)] = {__pyx_t_2, NULL}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 782, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_board_size, __pyx_t_3, __pyx_t_7, __pyx_callargs+1, 0) < (0)) __PYX_ERR(0, 782, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_pieces, ((PyObject *)__pyx_v_self->piece_set), __pyx_t_7, __pyx_callargs+1, 1) < (0)) __PYX_ERR(0, 782, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_num_players, __pyx_t_4, __pyx_t_7, __pyx_callargs+1, 2) < (0)) __PYX_ERR(0, 782, __pyx_L1_error) + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_corner_rule, __pyx_t_5, __pyx_t_7, __pyx_callargs+1, 3) < (0)) __PYX_ERR(0, 782, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 782, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + } + __pyx_v_new_game = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":789 + * ) + * + * new_game.board = self.board.copy() # <<<<<<<<<<<<<< + * new_game.current_player = self.current_player + * new_game.rounds = self.rounds +*/ + __pyx_t_7 = __pyx_v_self->board; + __Pyx_INCREF(__pyx_t_7); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 789, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_new_game->board); + __Pyx_DECREF(__pyx_v_new_game->board); + __pyx_v_new_game->board = __pyx_t_1; + __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":790 + * + * new_game.board = self.board.copy() + * new_game.current_player = self.current_player # <<<<<<<<<<<<<< + * new_game.rounds = self.rounds + * new_game.game_over = self.game_over +*/ + __pyx_t_8 = __pyx_v_self->current_player; + __pyx_v_new_game->current_player = __pyx_t_8; + + /* "blokus_gym/core/blokus_cython.pyx":791 + * new_game.board = self.board.copy() + * new_game.current_player = self.current_player + * new_game.rounds = self.rounds # <<<<<<<<<<<<<< + * new_game.game_over = self.game_over + * +*/ + __pyx_t_8 = __pyx_v_self->rounds; + __pyx_v_new_game->rounds = __pyx_t_8; + + /* "blokus_gym/core/blokus_cython.pyx":792 + * new_game.current_player = self.current_player + * new_game.rounds = self.rounds + * new_game.game_over = self.game_over # <<<<<<<<<<<<<< + * + * for i, p in enumerate(self.players): +*/ + __pyx_t_9 = __pyx_v_self->game_over; + __pyx_v_new_game->game_over = __pyx_t_9; + + /* "blokus_gym/core/blokus_cython.pyx":794 + * new_game.game_over = self.game_over + * + * for i, p in enumerate(self.players): # <<<<<<<<<<<<<< + * new_game.players[i].available_pieces = p.available_pieces.copy() + * new_game.players[i].corners = p.corners.copy() +*/ + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __pyx_t_1 = __pyx_mstate_global->__pyx_int_0; + __pyx_t_7 = __pyx_v_self->players; __Pyx_INCREF(__pyx_t_7); + __pyx_t_10 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_7); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(0, 794, __pyx_L1_error) + #endif + if (__pyx_t_10 >= __pyx_temp) break; + } + __pyx_t_5 = __Pyx_PyList_GET_ITEM_REF(__pyx_t_7, __pyx_t_10, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_10; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 794, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF_SET(__pyx_v_p, __pyx_t_5); + __pyx_t_5 = 0; + __Pyx_INCREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_1); + __pyx_t_5 = __Pyx_PyLong_AddObjC(__pyx_t_1, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 794, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); + __pyx_t_1 = __pyx_t_5; + __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":795 + * + * for i, p in enumerate(self.players): + * new_game.players[i].available_pieces = p.available_pieces.copy() # <<<<<<<<<<<<<< + * new_game.players[i].corners = p.corners.copy() + * new_game.players[i].score = p.score +*/ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_p, __pyx_mstate_global->__pyx_n_u_available_pieces); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 795, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_4); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, NULL}; + __pyx_t_5 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 795, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + if (unlikely(__pyx_v_new_game->players == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 795, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_new_game->players, __pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 795, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_PyObject_SetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_available_pieces, __pyx_t_5) < (0)) __PYX_ERR(0, 795, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":796 + * for i, p in enumerate(self.players): + * new_game.players[i].available_pieces = p.available_pieces.copy() + * new_game.players[i].corners = p.corners.copy() # <<<<<<<<<<<<<< + * new_game.players[i].score = p.score + * new_game.players[i].has_started = p.has_started +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_p, __pyx_mstate_global->__pyx_n_u_corners); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 796, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, NULL}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_copy, __pyx_callargs+__pyx_t_6, (1-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 796, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + if (unlikely(__pyx_v_new_game->players == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 796, __pyx_L1_error) + } + __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_new_game->players, __pyx_v_i); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 796, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_PyObject_SetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_corners, __pyx_t_3) < (0)) __PYX_ERR(0, 796, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":797 + * new_game.players[i].available_pieces = p.available_pieces.copy() + * new_game.players[i].corners = p.corners.copy() + * new_game.players[i].score = p.score # <<<<<<<<<<<<<< + * new_game.players[i].has_started = p.has_started + * new_game.players[i].can_move = p.can_move +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_p, __pyx_mstate_global->__pyx_n_u_score); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 797, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (unlikely(__pyx_v_new_game->players == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 797, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_new_game->players, __pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 797, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_PyObject_SetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_score, __pyx_t_4) < (0)) __PYX_ERR(0, 797, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":798 + * new_game.players[i].corners = p.corners.copy() + * new_game.players[i].score = p.score + * new_game.players[i].has_started = p.has_started # <<<<<<<<<<<<<< + * new_game.players[i].can_move = p.can_move + * +*/ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_p, __pyx_mstate_global->__pyx_n_u_has_started); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 798, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (unlikely(__pyx_v_new_game->players == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 798, __pyx_L1_error) + } + __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_new_game->players, __pyx_v_i); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 798, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_PyObject_SetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_has_started, __pyx_t_3) < (0)) __PYX_ERR(0, 798, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":799 + * new_game.players[i].score = p.score + * new_game.players[i].has_started = p.has_started + * new_game.players[i].can_move = p.can_move # <<<<<<<<<<<<<< + * + * return new_game +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_p, __pyx_mstate_global->__pyx_n_u_can_move); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 799, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (unlikely(__pyx_v_new_game->players == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable"); + __PYX_ERR(0, 799, __pyx_L1_error) + } + __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_new_game->players, __pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 799, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_PyObject_SetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_can_move, __pyx_t_4) < (0)) __PYX_ERR(0, 799, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":794 + * new_game.game_over = self.game_over + * + * for i, p in enumerate(self.players): # <<<<<<<<<<<<<< + * new_game.players[i].available_pieces = p.available_pieces.copy() + * new_game.players[i].corners = p.corners.copy() +*/ + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":801 + * new_game.players[i].can_move = p.can_move + * + * return new_game # <<<<<<<<<<<<<< +*/ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_new_game); + __pyx_r = __pyx_v_new_game; + goto __pyx_L0; + + /* "blokus_gym/core/blokus_cython.pyx":780 + * } + * + * def copy(self) -> BlokusGame: # <<<<<<<<<<<<<< + * """Create a deep copy of the game.""" + * cdef BlokusGame new_game = BlokusGame( +*/ + + /* 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_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_new_game); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_v_p); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":399 + * """Cython-optimized Blokus game engine.""" + * + * cdef public int board_size # <<<<<<<<<<<<<< + * cdef public PieceSet piece_set + * cdef public int num_players +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_10board_size_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_10board_size_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_10board_size___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_10board_size___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__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); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->board_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 399, __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("blokus_gym.core.blokus_cython.BlokusGame.board_size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_10board_size_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_10board_size_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_10board_size_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_10board_size_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 399, __pyx_L1_error) + __pyx_v_self->board_size = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.board_size.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":400 + * + * cdef public int board_size + * cdef public PieceSet piece_set # <<<<<<<<<<<<<< + * cdef public int num_players + * cdef public bint corner_rule +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_9piece_set_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_9piece_set_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_9piece_set___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_9piece_set___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self->piece_set); + __pyx_r = ((PyObject *)__pyx_v_self->piece_set); + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_9piece_set_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_9piece_set_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_9piece_set_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_9piece_set_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, 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("__set__", 0); + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet))))) __PYX_ERR(0, 400, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v_self->piece_set); + __Pyx_DECREF((PyObject *)__pyx_v_self->piece_set); + __pyx_v_self->piece_set = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.piece_set.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_9piece_set_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_9piece_set_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_9piece_set_4__del__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_9piece_set_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF((PyObject *)__pyx_v_self->piece_set); + __Pyx_DECREF((PyObject *)__pyx_v_self->piece_set); + __pyx_v_self->piece_set = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":401 + * cdef public int board_size + * cdef public PieceSet piece_set + * cdef public int num_players # <<<<<<<<<<<<<< + * cdef public bint corner_rule + * cdef public object board +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_11num_players_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_11num_players_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_11num_players___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_11num_players___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__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); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->num_players); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 401, __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("blokus_gym.core.blokus_cython.BlokusGame.num_players.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_11num_players_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_11num_players_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_11num_players_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_11num_players_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 401, __pyx_L1_error) + __pyx_v_self->num_players = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.num_players.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":402 + * cdef public PieceSet piece_set + * cdef public int num_players + * cdef public bint corner_rule # <<<<<<<<<<<<<< + * cdef public object board + * cdef public list players +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_11corner_rule_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_11corner_rule_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_11corner_rule___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_11corner_rule___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__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); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->corner_rule); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 402, __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("blokus_gym.core.blokus_cython.BlokusGame.corner_rule.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_11corner_rule_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_11corner_rule_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_11corner_rule_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_11corner_rule_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 402, __pyx_L1_error) + __pyx_v_self->corner_rule = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.corner_rule.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":403 + * cdef public int num_players + * cdef public bint corner_rule + * cdef public object board # <<<<<<<<<<<<<< + * cdef public list players + * cdef public int current_player +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_5board_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_5board_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_5board___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_5board___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->board); + __pyx_r = __pyx_v_self->board; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_5board_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_5board_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_5board_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_5board_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__", 0); + __Pyx_INCREF(__pyx_v_value); + __Pyx_GIVEREF(__pyx_v_value); + __Pyx_GOTREF(__pyx_v_self->board); + __Pyx_DECREF(__pyx_v_self->board); + __pyx_v_self->board = __pyx_v_value; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_5board_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_5board_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_5board_4__del__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_5board_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->board); + __Pyx_DECREF(__pyx_v_self->board); + __pyx_v_self->board = Py_None; + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":404 + * cdef public bint corner_rule + * cdef public object board + * cdef public list players # <<<<<<<<<<<<<< + * cdef public int current_player + * cdef public int rounds +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_7players_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_7players_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_7players___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_7players___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->players); + __pyx_r = __pyx_v_self->players; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_7players_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_7players_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_7players_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_7players_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, 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("__set__", 0); + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 404, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->players); + __Pyx_DECREF(__pyx_v_self->players); + __pyx_v_self->players = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.players.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_7players_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_7players_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_7players_4__del__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_7players_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->players); + __Pyx_DECREF(__pyx_v_self->players); + __pyx_v_self->players = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":405 + * cdef public object board + * cdef public list players + * cdef public int current_player # <<<<<<<<<<<<<< + * cdef public int rounds + * cdef public bint game_over +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_14current_player_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_14current_player_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_14current_player___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_14current_player___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__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); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->current_player); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 405, __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("blokus_gym.core.blokus_cython.BlokusGame.current_player.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_14current_player_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_14current_player_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_14current_player_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_14current_player_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 405, __pyx_L1_error) + __pyx_v_self->current_player = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.current_player.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":406 + * cdef public list players + * cdef public int current_player + * cdef public int rounds # <<<<<<<<<<<<<< + * cdef public bint game_over + * cdef public list _action_moves +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_6rounds_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_6rounds_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_6rounds___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_6rounds___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__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); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->rounds); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 406, __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("blokus_gym.core.blokus_cython.BlokusGame.rounds.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_6rounds_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_6rounds_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_6rounds_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_6rounds_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __pyx_t_1 = __Pyx_PyLong_As_int(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 406, __pyx_L1_error) + __pyx_v_self->rounds = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.rounds.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":407 + * cdef public int current_player + * cdef public int rounds + * cdef public bint game_over # <<<<<<<<<<<<<< + * cdef public list _action_moves + * cdef public dict _move_to_action +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_9game_over_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_9game_over_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_9game_over___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_9game_over___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__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); + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyBool_FromLong(__pyx_v_self->game_over); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 407, __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("blokus_gym.core.blokus_cython.BlokusGame.game_over.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_9game_over_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_9game_over_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_9game_over_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_9game_over_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v_value) { + int __pyx_r; + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_value); if (unlikely((__pyx_t_1 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 407, __pyx_L1_error) + __pyx_v_self->game_over = __pyx_t_1; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.game_over.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":408 + * cdef public int rounds + * cdef public bint game_over + * cdef public list _action_moves # <<<<<<<<<<<<<< + * cdef public dict _move_to_action + * cdef public list _actions_by_piece +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_13_action_moves_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_13_action_moves_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_13_action_moves___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_13_action_moves___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_action_moves); + __pyx_r = __pyx_v_self->_action_moves; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_13_action_moves_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_13_action_moves_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_13_action_moves_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_13_action_moves_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, 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("__set__", 0); + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 408, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_action_moves); + __Pyx_DECREF(__pyx_v_self->_action_moves); + __pyx_v_self->_action_moves = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame._action_moves.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_13_action_moves_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_13_action_moves_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_13_action_moves_4__del__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_13_action_moves_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_action_moves); + __Pyx_DECREF(__pyx_v_self->_action_moves); + __pyx_v_self->_action_moves = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":409 + * cdef public bint game_over + * cdef public list _action_moves + * cdef public dict _move_to_action # <<<<<<<<<<<<<< + * cdef public list _actions_by_piece + * cdef public list _starting_corners +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_15_move_to_action_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_15_move_to_action_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_15_move_to_action___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_15_move_to_action___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_move_to_action); + __pyx_r = __pyx_v_self->_move_to_action; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_15_move_to_action_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_15_move_to_action_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_15_move_to_action_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_15_move_to_action_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, 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("__set__", 0); + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyDict_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("dict", __pyx_t_1))) __PYX_ERR(0, 409, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_move_to_action); + __Pyx_DECREF(__pyx_v_self->_move_to_action); + __pyx_v_self->_move_to_action = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame._move_to_action.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_15_move_to_action_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_15_move_to_action_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_15_move_to_action_4__del__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_15_move_to_action_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_move_to_action); + __Pyx_DECREF(__pyx_v_self->_move_to_action); + __pyx_v_self->_move_to_action = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":410 + * cdef public list _action_moves + * cdef public dict _move_to_action + * cdef public list _actions_by_piece # <<<<<<<<<<<<<< + * cdef public list _starting_corners + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_actions_by_piece_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_actions_by_piece_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_actions_by_piece___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_actions_by_piece___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_actions_by_piece); + __pyx_r = __pyx_v_self->_actions_by_piece; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_actions_by_piece_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_actions_by_piece_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_actions_by_piece_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_actions_by_piece_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, 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("__set__", 0); + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 410, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_actions_by_piece); + __Pyx_DECREF(__pyx_v_self->_actions_by_piece); + __pyx_v_self->_actions_by_piece = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame._actions_by_piece.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_actions_by_piece_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_actions_by_piece_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_actions_by_piece_4__del__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_actions_by_piece_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_actions_by_piece); + __Pyx_DECREF(__pyx_v_self->_actions_by_piece); + __pyx_v_self->_actions_by_piece = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "blokus_gym/core/blokus_cython.pyx":411 + * cdef public dict _move_to_action + * cdef public list _actions_by_piece + * cdef public list _starting_corners # <<<<<<<<<<<<<< + * + * def __init__(self, int board_size=20, PieceSet pieces=None, int num_players=4, bint corner_rule=True): +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_starting_corners_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_starting_corners_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_starting_corners___get__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_starting_corners___get__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__", 0); + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_starting_corners); + __pyx_r = __pyx_v_self->_starting_corners; + goto __pyx_L0; + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_starting_corners_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_starting_corners_3__set__(PyObject *__pyx_v_self, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__set__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_starting_corners_2__set__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_starting_corners_2__set__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, 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("__set__", 0); + __pyx_t_1 = __pyx_v_value; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(0, 411, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v_self->_starting_corners); + __Pyx_DECREF(__pyx_v_self->_starting_corners); + __pyx_v_self->_starting_corners = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame._starting_corners.__set__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_starting_corners_5__del__(PyObject *__pyx_v_self); /*proto*/ +static int __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_starting_corners_5__del__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_starting_corners_4__del__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_starting_corners_4__del__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__del__", 0); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + __Pyx_GOTREF(__pyx_v_self->_starting_corners); + __Pyx_DECREF(__pyx_v_self->_starting_corners); + __pyx_v_self->_starting_corners = ((PyObject*)Py_None); + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_27__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_27__reduce_cython__ = {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_27__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_27__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_26__reduce_cython__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_26__reduce_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__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; + 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; + int __pyx_t_9; + 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._action_moves, self._actions_by_piece, self._move_to_action, self._starting_corners, self.board, self.board_size, self.corner_rule, self.current_player, self.game_over, self.num_players, self.piece_set, self.players, self.rounds) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: +*/ + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->board_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_self->corner_rule); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_self->current_player); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_self->game_over); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_self->num_players); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_self->rounds); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyTuple_New(13); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_INCREF(__pyx_v_self->_action_moves); + __Pyx_GIVEREF(__pyx_v_self->_action_moves); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_v_self->_action_moves) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->_actions_by_piece); + __Pyx_GIVEREF(__pyx_v_self->_actions_by_piece); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_v_self->_actions_by_piece) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->_move_to_action); + __Pyx_GIVEREF(__pyx_v_self->_move_to_action); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_v_self->_move_to_action) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->_starting_corners); + __Pyx_GIVEREF(__pyx_v_self->_starting_corners); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 3, __pyx_v_self->_starting_corners) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->board); + __Pyx_GIVEREF(__pyx_v_self->board); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 4, __pyx_v_self->board) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 5, __pyx_t_1) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 6, __pyx_t_2) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 7, __pyx_t_3) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 8, __pyx_t_4) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 9, __pyx_t_5) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF((PyObject *)__pyx_v_self->piece_set); + __Pyx_GIVEREF((PyObject *)__pyx_v_self->piece_set); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 10, ((PyObject *)__pyx_v_self->piece_set)) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_self->players); + __Pyx_GIVEREF(__pyx_v_self->players); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 11, __pyx_v_self->players) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 12, __pyx_t_6) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_5 = 0; + __pyx_t_6 = 0; + __pyx_v_state = ((PyObject*)__pyx_t_7); + __pyx_t_7 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self._action_moves, self._actions_by_piece, self._move_to_action, self._starting_corners, self.board, self.board_size, self.corner_rule, self.current_player, self.game_over, self.num_players, self.piece_set, self.players, self.rounds) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None and _dict: + * state += (_dict,) +*/ + __pyx_t_7 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_dict, Py_None); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_v__dict = __pyx_t_7; + __pyx_t_7 = 0; + + /* "(tree fragment)":7 + * state = (self._action_moves, self._actions_by_piece, self._move_to_action, self._starting_corners, self.board, self.board_size, self.corner_rule, self.current_player, self.game_over, self.num_players, self.piece_set, self.players, self.rounds) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + __pyx_t_9 = (__pyx_v__dict != Py_None); + if (__pyx_t_9) { + } else { + __pyx_t_8 = __pyx_t_9; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_9 = __Pyx_PyObject_IsTrue(__pyx_v__dict); if (unlikely((__pyx_t_9 < 0))) __PYX_ERR(1, 7, __pyx_L1_error) + __pyx_t_8 = __pyx_t_9; + __pyx_L4_bool_binop_done:; + if (__pyx_t_8) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: +*/ + __pyx_t_7 = PyTuple_New(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_v__dict) != (0)) __PYX_ERR(1, 8, __pyx_L1_error); + __pyx_t_6 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_6)); + __pyx_t_6 = 0; + + /* "(tree fragment)":9 + * if _dict is not None and _dict: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = self._action_moves is not None or self._actions_by_piece is not None or self._move_to_action is not None or self._starting_corners is not None or self.board is not None or self.piece_set is not None or self.players is not None +*/ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self._action_moves, self._actions_by_piece, self._move_to_action, self._starting_corners, self.board, self.board_size, self.corner_rule, self.current_player, self.game_over, self.num_players, self.piece_set, self.players, self.rounds) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = self._action_moves is not None or self._actions_by_piece is not None or self._move_to_action is not None or self._starting_corners is not None or self.board is not None or self.piece_set is not None or self.players is not None # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_BlokusGame, (type(self), 0x2eba6e9, None), state +*/ + /*else*/ { + __pyx_t_9 = (__pyx_v_self->_action_moves != ((PyObject*)Py_None)); + if (!__pyx_t_9) { + } else { + __pyx_t_8 = __pyx_t_9; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_9 = (__pyx_v_self->_actions_by_piece != ((PyObject*)Py_None)); + if (!__pyx_t_9) { + } else { + __pyx_t_8 = __pyx_t_9; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_9 = (__pyx_v_self->_move_to_action != ((PyObject*)Py_None)); + if (!__pyx_t_9) { + } else { + __pyx_t_8 = __pyx_t_9; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_9 = (__pyx_v_self->_starting_corners != ((PyObject*)Py_None)); + if (!__pyx_t_9) { + } else { + __pyx_t_8 = __pyx_t_9; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_9 = (__pyx_v_self->board != Py_None); + if (!__pyx_t_9) { + } else { + __pyx_t_8 = __pyx_t_9; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_9 = (((PyObject *)__pyx_v_self->piece_set) != Py_None); + if (!__pyx_t_9) { + } else { + __pyx_t_8 = __pyx_t_9; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_9 = (__pyx_v_self->players != ((PyObject*)Py_None)); + __pyx_t_8 = __pyx_t_9; + __pyx_L6_bool_binop_done:; + __pyx_v_use_setstate = __pyx_t_8; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = self._action_moves is not None or self._actions_by_piece is not None or self._move_to_action is not None or self._starting_corners is not None or self.board is not None or self.piece_set is not None or self.players is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_BlokusGame, (type(self), 0x2eba6e9, None), state + * else: +*/ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = self._action_moves is not None or self._actions_by_piece is not None or self._move_to_action is not None or self._starting_corners is not None or self.board is not None or self.piece_set is not None or self.players is not None + * if use_setstate: + * return __pyx_unpickle_BlokusGame, (type(self), 0x2eba6e9, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_BlokusGame, (type(self), 0x2eba6e9, state) +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_BlokusGame); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_48998121); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_48998121); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_mstate_global->__pyx_int_48998121) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 2, Py_None) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __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_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_6) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_7) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = self._action_moves is not None or self._actions_by_piece is not None or self._move_to_action is not None or self._starting_corners is not None or self.board is not None or self.piece_set is not None or self.players is not None + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_BlokusGame, (type(self), 0x2eba6e9, None), state + * else: +*/ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_BlokusGame, (type(self), 0x2eba6e9, None), state + * else: + * return __pyx_unpickle_BlokusGame, (type(self), 0x2eba6e9, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_BlokusGame__set_state(self, __pyx_state) +*/ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_BlokusGame); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_48998121); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_48998121); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_mstate_global->__pyx_int_48998121) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_6 = PyTuple_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_5) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_7) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_7 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 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_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.__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_BlokusGame, (type(self), 0x2eba6e9, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_BlokusGame__set_state(self, __pyx_state) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_29__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_29__setstate_cython__ = {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_29__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_29__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 16, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(1, 16, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 16, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_28__setstate_cython__(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10BlokusGame_28__setstate_cython__(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":17 + * return __pyx_unpickle_BlokusGame, (type(self), 0x2eba6e9, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_BlokusGame__set_state(self, __pyx_state) # <<<<<<<<<<<<<< +*/ + __pyx_t_1 = __pyx_v___pyx_state; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 17, __pyx_L1_error) + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared 'not None'"); + __PYX_ERR(1, 17, __pyx_L1_error) + } + __pyx_t_2 = __pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_BlokusGame__set_state(__pyx_v_self, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_BlokusGame, (type(self), 0x2eba6e9, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_BlokusGame__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_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.BlokusGame.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_Board(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x0510d2c, 0x0b84c10, 0x0bc2a6c, b'_occupied_cache, grid, size') +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_1__pyx_unpickle_Board(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_1__pyx_unpickle_Board = {"__pyx_unpickle_Board", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_1__pyx_unpickle_Board, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_1__pyx_unpickle_Board(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Board (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_type,&__pyx_mstate_global->__pyx_n_u_pyx_checksum,&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 4, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__pyx_unpickle_Board", 0) < (0)) __PYX_ERR(1, 4, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Board", 1, 3, 3, i); __PYX_ERR(1, 4, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 4, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 4, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 4, __pyx_L3_error) + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyLong_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 4, __pyx_L3_error) + __pyx_v___pyx_state = ((PyObject*)values[2]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Board", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 4, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_Board", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v___pyx_state), (&PyTuple_Type), 1, "__pyx_state", 1))) __PYX_ERR(1, 4, __pyx_L1_error) + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython___pyx_unpickle_Board(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython___pyx_unpickle_Board(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Board", 0); + + /* "(tree fragment)":6 + * def __pyx_unpickle_Board(__pyx_type, long __pyx_checksum, tuple __pyx_state): + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x0510d2c, 0x0b84c10, 0x0bc2a6c, b'_occupied_cache, grid, size') # <<<<<<<<<<<<<< + * __pyx_result = Board.__new__(__pyx_type) + * if __pyx_state is not None: +*/ + __pyx_t_1 = __Pyx_CheckUnpickleChecksum(__pyx_v___pyx_checksum, 0x0510d2c, 0x0b84c10, 0x0bc2a6c, __pyx_k_occupied_cache_grid_size); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 6, __pyx_L1_error) + + /* "(tree fragment)":7 + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x0510d2c, 0x0b84c10, 0x0bc2a6c, b'_occupied_cache, grid, size') + * __pyx_result = Board.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Board__set_state( __pyx_result, __pyx_state) +*/ + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v___pyx_type}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_new, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_v___pyx_result = __pyx_t_2; + __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x0510d2c, 0x0b84c10, 0x0bc2a6c, b'_occupied_cache, grid, size') + * __pyx_result = Board.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Board__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + __pyx_t_5 = (__pyx_v___pyx_state != ((PyObject*)Py_None)); + if (__pyx_t_5) { + + /* "(tree fragment)":9 + * __pyx_result = Board.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Board__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Board__set_state(Board __pyx_result, __pyx_state: tuple): +*/ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared 'not None'"); + __PYX_ERR(1, 9, __pyx_L1_error) + } + __pyx_t_2 = __pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_Board__set_state(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)__pyx_v___pyx_result), __pyx_v___pyx_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x0510d2c, 0x0b84c10, 0x0bc2a6c, b'_occupied_cache, grid, size') + * __pyx_result = Board.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Board__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Board__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Board__set_state(Board __pyx_result, __pyx_state: tuple): + * __pyx_result._occupied_cache = __pyx_state[0]; __pyx_result.grid = __pyx_state[1]; __pyx_result.size = __pyx_state[2] +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_Board(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x0510d2c, 0x0b84c10, 0x0bc2a6c, b'_occupied_cache, grid, size') +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_Board", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Board__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Board__set_state(Board __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result._occupied_cache = __pyx_state[0]; __pyx_result.grid = __pyx_state[1]; __pyx_result.size = __pyx_state[2] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 3) +*/ + +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_Board__set_state(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Board__set_state", 0); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Board__set_state(Board __pyx_result, __pyx_state: tuple): + * __pyx_result._occupied_cache = __pyx_state[0]; __pyx_result.grid = __pyx_state[1]; __pyx_result.size = __pyx_state[2] # <<<<<<<<<<<<<< + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 3) +*/ + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyDict_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("dict", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_occupied_cache); + __Pyx_DECREF(__pyx_v___pyx_result->_occupied_cache); + __pyx_v___pyx_result->_occupied_cache = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_nn___pyx_t_5numpy_int8_t(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_XCLEAR_MEMVIEW(&__pyx_v___pyx_result->grid, 0); + __pyx_v___pyx_result->grid = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->size = __pyx_t_3; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Board__set_state(Board __pyx_result, __pyx_state: tuple): + * __pyx_result._occupied_cache = __pyx_state[0]; __pyx_result.grid = __pyx_state[1]; __pyx_result.size = __pyx_state[2] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 3) # <<<<<<<<<<<<<< +*/ + __pyx_t_3 = __Pyx_UpdateUnpickledDict(((PyObject *)__pyx_v___pyx_result), __pyx_v___pyx_state, 3); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + + /* "(tree fragment)":11 + * __pyx_unpickle_Board__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Board__set_state(Board __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result._occupied_cache = __pyx_state[0]; __pyx_result.grid = __pyx_state[1]; __pyx_result.size = __pyx_state[2] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 3) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_Board__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_Move(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x4546268, 0xdd5e42e, 0x622b8ac, b'orientation_id, piece_id, x, y') +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_3__pyx_unpickle_Move(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_3__pyx_unpickle_Move = {"__pyx_unpickle_Move", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_3__pyx_unpickle_Move, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_3__pyx_unpickle_Move(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Move (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_type,&__pyx_mstate_global->__pyx_n_u_pyx_checksum,&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 4, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__pyx_unpickle_Move", 0) < (0)) __PYX_ERR(1, 4, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Move", 1, 3, 3, i); __PYX_ERR(1, 4, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 4, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 4, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 4, __pyx_L3_error) + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyLong_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 4, __pyx_L3_error) + __pyx_v___pyx_state = ((PyObject*)values[2]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Move", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 4, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_Move", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v___pyx_state), (&PyTuple_Type), 1, "__pyx_state", 1))) __PYX_ERR(1, 4, __pyx_L1_error) + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_2__pyx_unpickle_Move(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_2__pyx_unpickle_Move(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Move", 0); + + /* "(tree fragment)":6 + * def __pyx_unpickle_Move(__pyx_type, long __pyx_checksum, tuple __pyx_state): + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x4546268, 0xdd5e42e, 0x622b8ac, b'orientation_id, piece_id, x, y') # <<<<<<<<<<<<<< + * __pyx_result = Move.__new__(__pyx_type) + * if __pyx_state is not None: +*/ + __pyx_t_1 = __Pyx_CheckUnpickleChecksum(__pyx_v___pyx_checksum, 0x4546268, 0xdd5e42e, 0x622b8ac, __pyx_k_orientation_id_piece_id_x_y); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 6, __pyx_L1_error) + + /* "(tree fragment)":7 + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x4546268, 0xdd5e42e, 0x622b8ac, b'orientation_id, piece_id, x, y') + * __pyx_result = Move.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Move__set_state( __pyx_result, __pyx_state) +*/ + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v___pyx_type}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_new, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_v___pyx_result = __pyx_t_2; + __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x4546268, 0xdd5e42e, 0x622b8ac, b'orientation_id, piece_id, x, y') + * __pyx_result = Move.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Move__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + __pyx_t_5 = (__pyx_v___pyx_state != ((PyObject*)Py_None)); + if (__pyx_t_5) { + + /* "(tree fragment)":9 + * __pyx_result = Move.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Move__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Move__set_state(Move __pyx_result, __pyx_state: tuple): +*/ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared 'not None'"); + __PYX_ERR(1, 9, __pyx_L1_error) + } + __pyx_t_2 = __pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_Move__set_state(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *)__pyx_v___pyx_result), __pyx_v___pyx_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x4546268, 0xdd5e42e, 0x622b8ac, b'orientation_id, piece_id, x, y') + * __pyx_result = Move.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Move__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Move__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Move__set_state(Move __pyx_result, __pyx_state: tuple): + * __pyx_result.orientation_id = __pyx_state[0]; __pyx_result.piece_id = __pyx_state[1]; __pyx_result.x = __pyx_state[2]; __pyx_result.y = __pyx_state[3] +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_Move(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x4546268, 0xdd5e42e, 0x622b8ac, b'orientation_id, piece_id, x, y') +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_Move", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Move__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Move__set_state(Move __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result.orientation_id = __pyx_state[0]; __pyx_result.piece_id = __pyx_state[1]; __pyx_result.x = __pyx_state[2]; __pyx_result.y = __pyx_state[3] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 4) +*/ + +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_Move__set_state(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + 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("__pyx_unpickle_Move__set_state", 0); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Move__set_state(Move __pyx_result, __pyx_state: tuple): + * __pyx_result.orientation_id = __pyx_state[0]; __pyx_result.piece_id = __pyx_state[1]; __pyx_result.x = __pyx_state[2]; __pyx_result.y = __pyx_state[3] # <<<<<<<<<<<<<< + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 4) +*/ + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->orientation_id = __pyx_t_2; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->piece_id = __pyx_t_2; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->x = __pyx_t_2; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->y = __pyx_t_2; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Move__set_state(Move __pyx_result, __pyx_state: tuple): + * __pyx_result.orientation_id = __pyx_state[0]; __pyx_result.piece_id = __pyx_state[1]; __pyx_result.x = __pyx_state[2]; __pyx_result.y = __pyx_state[3] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 4) # <<<<<<<<<<<<<< +*/ + __pyx_t_2 = __Pyx_UpdateUnpickledDict(((PyObject *)__pyx_v___pyx_result), __pyx_v___pyx_state, 4); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + + /* "(tree fragment)":11 + * __pyx_unpickle_Move__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Move__set_state(Move __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result.orientation_id = __pyx_state[0]; __pyx_result.piece_id = __pyx_state[1]; __pyx_result.x = __pyx_state[2]; __pyx_result.y = __pyx_state[3] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 4) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_Move__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_PieceOrientation(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xf86ecb3, 0x1b2f35d, 0x9c26469, b'corners, orientation_id, piece_id, squares') +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5__pyx_unpickle_PieceOrientation(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_5__pyx_unpickle_PieceOrientation = {"__pyx_unpickle_PieceOrientation", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5__pyx_unpickle_PieceOrientation, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_5__pyx_unpickle_PieceOrientation(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_PieceOrientation (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_type,&__pyx_mstate_global->__pyx_n_u_pyx_checksum,&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 4, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__pyx_unpickle_PieceOrientation", 0) < (0)) __PYX_ERR(1, 4, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PieceOrientation", 1, 3, 3, i); __PYX_ERR(1, 4, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 4, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 4, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 4, __pyx_L3_error) + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyLong_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 4, __pyx_L3_error) + __pyx_v___pyx_state = ((PyObject*)values[2]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PieceOrientation", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 4, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_PieceOrientation", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v___pyx_state), (&PyTuple_Type), 1, "__pyx_state", 1))) __PYX_ERR(1, 4, __pyx_L1_error) + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_4__pyx_unpickle_PieceOrientation(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_4__pyx_unpickle_PieceOrientation(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PieceOrientation", 0); + + /* "(tree fragment)":6 + * def __pyx_unpickle_PieceOrientation(__pyx_type, long __pyx_checksum, tuple __pyx_state): + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xf86ecb3, 0x1b2f35d, 0x9c26469, b'corners, orientation_id, piece_id, squares') # <<<<<<<<<<<<<< + * __pyx_result = PieceOrientation.__new__(__pyx_type) + * if __pyx_state is not None: +*/ + __pyx_t_1 = __Pyx_CheckUnpickleChecksum(__pyx_v___pyx_checksum, 0xf86ecb3, 0x1b2f35d, 0x9c26469, __pyx_k_corners_orientation_id_piece_id); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 6, __pyx_L1_error) + + /* "(tree fragment)":7 + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xf86ecb3, 0x1b2f35d, 0x9c26469, b'corners, orientation_id, piece_id, squares') + * __pyx_result = PieceOrientation.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_PieceOrientation__set_state( __pyx_result, __pyx_state) +*/ + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v___pyx_type}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_new, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_v___pyx_result = __pyx_t_2; + __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xf86ecb3, 0x1b2f35d, 0x9c26469, b'corners, orientation_id, piece_id, squares') + * __pyx_result = PieceOrientation.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PieceOrientation__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + __pyx_t_5 = (__pyx_v___pyx_state != ((PyObject*)Py_None)); + if (__pyx_t_5) { + + /* "(tree fragment)":9 + * __pyx_result = PieceOrientation.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_PieceOrientation__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_PieceOrientation__set_state(PieceOrientation __pyx_result, __pyx_state: tuple): +*/ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared 'not None'"); + __PYX_ERR(1, 9, __pyx_L1_error) + } + __pyx_t_2 = __pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_PieceOrientation__set_state(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)__pyx_v___pyx_result), __pyx_v___pyx_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xf86ecb3, 0x1b2f35d, 0x9c26469, b'corners, orientation_id, piece_id, squares') + * __pyx_result = PieceOrientation.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PieceOrientation__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_PieceOrientation__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_PieceOrientation__set_state(PieceOrientation __pyx_result, __pyx_state: tuple): + * __pyx_result.corners = __pyx_state[0]; __pyx_result.orientation_id = __pyx_state[1]; __pyx_result.piece_id = __pyx_state[2]; __pyx_result.squares = __pyx_state[3] +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_PieceOrientation(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xf86ecb3, 0x1b2f35d, 0x9c26469, b'corners, orientation_id, piece_id, squares') +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_PieceOrientation", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_PieceOrientation__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PieceOrientation__set_state(PieceOrientation __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result.corners = __pyx_state[0]; __pyx_result.orientation_id = __pyx_state[1]; __pyx_result.piece_id = __pyx_state[2]; __pyx_result.squares = __pyx_state[3] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 4) +*/ + +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_PieceOrientation__set_state(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + 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("__pyx_unpickle_PieceOrientation__set_state", 0); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PieceOrientation__set_state(PieceOrientation __pyx_result, __pyx_state: tuple): + * __pyx_result.corners = __pyx_state[0]; __pyx_result.orientation_id = __pyx_state[1]; __pyx_result.piece_id = __pyx_state[2]; __pyx_result.squares = __pyx_state[3] # <<<<<<<<<<<<<< + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 4) +*/ + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->corners); + __Pyx_DECREF(__pyx_v___pyx_result->corners); + __pyx_v___pyx_result->corners = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->orientation_id = __pyx_t_2; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->piece_id = __pyx_t_2; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->squares); + __Pyx_DECREF(__pyx_v___pyx_result->squares); + __pyx_v___pyx_result->squares = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_PieceOrientation__set_state(PieceOrientation __pyx_result, __pyx_state: tuple): + * __pyx_result.corners = __pyx_state[0]; __pyx_result.orientation_id = __pyx_state[1]; __pyx_result.piece_id = __pyx_state[2]; __pyx_result.squares = __pyx_state[3] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 4) # <<<<<<<<<<<<<< +*/ + __pyx_t_2 = __Pyx_UpdateUnpickledDict(((PyObject *)__pyx_v___pyx_result), __pyx_v___pyx_state, 4); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + + /* "(tree fragment)":11 + * __pyx_unpickle_PieceOrientation__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PieceOrientation__set_state(PieceOrientation __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result.corners = __pyx_state[0]; __pyx_result.orientation_id = __pyx_state[1]; __pyx_result.piece_id = __pyx_state[2]; __pyx_result.squares = __pyx_state[3] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 4) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_PieceOrientation__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_Piece(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xb4de42d, 0x4ff3e21, 0x2a40087, b'name, squares') +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_7__pyx_unpickle_Piece(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_7__pyx_unpickle_Piece = {"__pyx_unpickle_Piece", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_7__pyx_unpickle_Piece, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_7__pyx_unpickle_Piece(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Piece (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_type,&__pyx_mstate_global->__pyx_n_u_pyx_checksum,&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 4, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__pyx_unpickle_Piece", 0) < (0)) __PYX_ERR(1, 4, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Piece", 1, 3, 3, i); __PYX_ERR(1, 4, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 4, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 4, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 4, __pyx_L3_error) + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyLong_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 4, __pyx_L3_error) + __pyx_v___pyx_state = ((PyObject*)values[2]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Piece", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 4, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_Piece", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v___pyx_state), (&PyTuple_Type), 1, "__pyx_state", 1))) __PYX_ERR(1, 4, __pyx_L1_error) + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_6__pyx_unpickle_Piece(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_6__pyx_unpickle_Piece(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Piece", 0); + + /* "(tree fragment)":6 + * def __pyx_unpickle_Piece(__pyx_type, long __pyx_checksum, tuple __pyx_state): + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xb4de42d, 0x4ff3e21, 0x2a40087, b'name, squares') # <<<<<<<<<<<<<< + * __pyx_result = Piece.__new__(__pyx_type) + * if __pyx_state is not None: +*/ + __pyx_t_1 = __Pyx_CheckUnpickleChecksum(__pyx_v___pyx_checksum, 0xb4de42d, 0x4ff3e21, 0x2a40087, __pyx_k_name_squares); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 6, __pyx_L1_error) + + /* "(tree fragment)":7 + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xb4de42d, 0x4ff3e21, 0x2a40087, b'name, squares') + * __pyx_result = Piece.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Piece__set_state( __pyx_result, __pyx_state) +*/ + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v___pyx_type}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_new, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_v___pyx_result = __pyx_t_2; + __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xb4de42d, 0x4ff3e21, 0x2a40087, b'name, squares') + * __pyx_result = Piece.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Piece__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + __pyx_t_5 = (__pyx_v___pyx_state != ((PyObject*)Py_None)); + if (__pyx_t_5) { + + /* "(tree fragment)":9 + * __pyx_result = Piece.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Piece__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Piece__set_state(Piece __pyx_result, __pyx_state: tuple): +*/ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared 'not None'"); + __PYX_ERR(1, 9, __pyx_L1_error) + } + __pyx_t_2 = __pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_Piece__set_state(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_v___pyx_result), __pyx_v___pyx_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xb4de42d, 0x4ff3e21, 0x2a40087, b'name, squares') + * __pyx_result = Piece.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Piece__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Piece__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Piece__set_state(Piece __pyx_result, __pyx_state: tuple): + * __pyx_result.name = __pyx_state[0]; __pyx_result.squares = __pyx_state[1] +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_Piece(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xb4de42d, 0x4ff3e21, 0x2a40087, b'name, squares') +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_Piece", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Piece__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Piece__set_state(Piece __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0]; __pyx_result.squares = __pyx_state[1] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 2) +*/ + +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_Piece__set_state(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + 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("__pyx_unpickle_Piece__set_state", 0); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Piece__set_state(Piece __pyx_result, __pyx_state: tuple): + * __pyx_result.name = __pyx_state[0]; __pyx_result.squares = __pyx_state[1] # <<<<<<<<<<<<<< + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 2) +*/ + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyUnicode_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("str", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->name); + __Pyx_DECREF(__pyx_v___pyx_result->name); + __pyx_v___pyx_result->name = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); 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->squares); + __Pyx_DECREF(__pyx_v___pyx_result->squares); + __pyx_v___pyx_result->squares = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Piece__set_state(Piece __pyx_result, __pyx_state: tuple): + * __pyx_result.name = __pyx_state[0]; __pyx_result.squares = __pyx_state[1] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 2) # <<<<<<<<<<<<<< +*/ + __pyx_t_2 = __Pyx_UpdateUnpickledDict(((PyObject *)__pyx_v___pyx_result), __pyx_v___pyx_state, 2); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + + /* "(tree fragment)":11 + * __pyx_unpickle_Piece__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Piece__set_state(Piece __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0]; __pyx_result.squares = __pyx_state[1] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 2) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_Piece__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_PieceSet(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x0a4ef5f, 0x798f028, 0xb2ae89a, b'num_orientations, orientations, piece_id_map, piece_names, pieces') +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_9__pyx_unpickle_PieceSet(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_9__pyx_unpickle_PieceSet = {"__pyx_unpickle_PieceSet", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_9__pyx_unpickle_PieceSet, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_9__pyx_unpickle_PieceSet(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_PieceSet (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_type,&__pyx_mstate_global->__pyx_n_u_pyx_checksum,&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 4, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__pyx_unpickle_PieceSet", 0) < (0)) __PYX_ERR(1, 4, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PieceSet", 1, 3, 3, i); __PYX_ERR(1, 4, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 4, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 4, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 4, __pyx_L3_error) + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyLong_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 4, __pyx_L3_error) + __pyx_v___pyx_state = ((PyObject*)values[2]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PieceSet", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 4, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_PieceSet", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v___pyx_state), (&PyTuple_Type), 1, "__pyx_state", 1))) __PYX_ERR(1, 4, __pyx_L1_error) + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_8__pyx_unpickle_PieceSet(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_8__pyx_unpickle_PieceSet(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PieceSet", 0); + + /* "(tree fragment)":6 + * def __pyx_unpickle_PieceSet(__pyx_type, long __pyx_checksum, tuple __pyx_state): + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x0a4ef5f, 0x798f028, 0xb2ae89a, b'num_orientations, orientations, piece_id_map, piece_names, pieces') # <<<<<<<<<<<<<< + * __pyx_result = PieceSet.__new__(__pyx_type) + * if __pyx_state is not None: +*/ + __pyx_t_1 = __Pyx_CheckUnpickleChecksum(__pyx_v___pyx_checksum, 0x0a4ef5f, 0x798f028, 0xb2ae89a, __pyx_k_num_orientations_orientations_pi); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 6, __pyx_L1_error) + + /* "(tree fragment)":7 + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x0a4ef5f, 0x798f028, 0xb2ae89a, b'num_orientations, orientations, piece_id_map, piece_names, pieces') + * __pyx_result = PieceSet.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_PieceSet__set_state( __pyx_result, __pyx_state) +*/ + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v___pyx_type}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_new, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_v___pyx_result = __pyx_t_2; + __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x0a4ef5f, 0x798f028, 0xb2ae89a, b'num_orientations, orientations, piece_id_map, piece_names, pieces') + * __pyx_result = PieceSet.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PieceSet__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + __pyx_t_5 = (__pyx_v___pyx_state != ((PyObject*)Py_None)); + if (__pyx_t_5) { + + /* "(tree fragment)":9 + * __pyx_result = PieceSet.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_PieceSet__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_PieceSet__set_state(PieceSet __pyx_result, __pyx_state: tuple): +*/ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared 'not None'"); + __PYX_ERR(1, 9, __pyx_L1_error) + } + __pyx_t_2 = __pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_PieceSet__set_state(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_v___pyx_result), __pyx_v___pyx_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x0a4ef5f, 0x798f028, 0xb2ae89a, b'num_orientations, orientations, piece_id_map, piece_names, pieces') + * __pyx_result = PieceSet.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PieceSet__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_PieceSet__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_PieceSet__set_state(PieceSet __pyx_result, __pyx_state: tuple): + * __pyx_result.num_orientations = __pyx_state[0]; __pyx_result.orientations = __pyx_state[1]; __pyx_result.piece_id_map = __pyx_state[2]; __pyx_result.piece_names = __pyx_state[3]; __pyx_result.pieces = __pyx_state[4] +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_PieceSet(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x0a4ef5f, 0x798f028, 0xb2ae89a, b'num_orientations, orientations, piece_id_map, piece_names, pieces') +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_PieceSet", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_PieceSet__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PieceSet__set_state(PieceSet __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result.num_orientations = __pyx_state[0]; __pyx_result.orientations = __pyx_state[1]; __pyx_result.piece_id_map = __pyx_state[2]; __pyx_result.piece_names = __pyx_state[3]; __pyx_result.pieces = __pyx_state[4] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 5) +*/ + +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_PieceSet__set_state(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + 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("__pyx_unpickle_PieceSet__set_state", 0); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PieceSet__set_state(PieceSet __pyx_result, __pyx_state: tuple): + * __pyx_result.num_orientations = __pyx_state[0]; __pyx_result.orientations = __pyx_state[1]; __pyx_result.piece_id_map = __pyx_state[2]; __pyx_result.piece_names = __pyx_state[3]; __pyx_result.pieces = __pyx_state[4] # <<<<<<<<<<<<<< + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 5) +*/ + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->num_orientations = __pyx_t_2; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->orientations); + __Pyx_DECREF(__pyx_v___pyx_result->orientations); + __pyx_v___pyx_result->orientations = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyDict_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("dict", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->piece_id_map); + __Pyx_DECREF(__pyx_v___pyx_result->piece_id_map); + __pyx_v___pyx_result->piece_id_map = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->piece_names); + __Pyx_DECREF(__pyx_v___pyx_result->piece_names); + __pyx_v___pyx_result->piece_names = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->pieces); + __Pyx_DECREF(__pyx_v___pyx_result->pieces); + __pyx_v___pyx_result->pieces = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_PieceSet__set_state(PieceSet __pyx_result, __pyx_state: tuple): + * __pyx_result.num_orientations = __pyx_state[0]; __pyx_result.orientations = __pyx_state[1]; __pyx_result.piece_id_map = __pyx_state[2]; __pyx_result.piece_names = __pyx_state[3]; __pyx_result.pieces = __pyx_state[4] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 5) # <<<<<<<<<<<<<< +*/ + __pyx_t_2 = __Pyx_UpdateUnpickledDict(((PyObject *)__pyx_v___pyx_result), __pyx_v___pyx_state, 5); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + + /* "(tree fragment)":11 + * __pyx_unpickle_PieceSet__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PieceSet__set_state(PieceSet __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result.num_orientations = __pyx_state[0]; __pyx_result.orientations = __pyx_state[1]; __pyx_result.piece_id_map = __pyx_state[2]; __pyx_result.piece_names = __pyx_state[3]; __pyx_result.pieces = __pyx_state[4] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 5) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_PieceSet__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_PlayerState(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x820c4ca, 0x920c0b5, 0x70188c3, b'available_pieces, can_move, corners, has_started, idx, score') +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_11__pyx_unpickle_PlayerState(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_11__pyx_unpickle_PlayerState = {"__pyx_unpickle_PlayerState", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_11__pyx_unpickle_PlayerState, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_11__pyx_unpickle_PlayerState(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_PlayerState (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_type,&__pyx_mstate_global->__pyx_n_u_pyx_checksum,&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 4, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__pyx_unpickle_PlayerState", 0) < (0)) __PYX_ERR(1, 4, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PlayerState", 1, 3, 3, i); __PYX_ERR(1, 4, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 4, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 4, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 4, __pyx_L3_error) + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyLong_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 4, __pyx_L3_error) + __pyx_v___pyx_state = ((PyObject*)values[2]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_PlayerState", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 4, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_PlayerState", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v___pyx_state), (&PyTuple_Type), 1, "__pyx_state", 1))) __PYX_ERR(1, 4, __pyx_L1_error) + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_10__pyx_unpickle_PlayerState(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_10__pyx_unpickle_PlayerState(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PlayerState", 0); + + /* "(tree fragment)":6 + * def __pyx_unpickle_PlayerState(__pyx_type, long __pyx_checksum, tuple __pyx_state): + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x820c4ca, 0x920c0b5, 0x70188c3, b'available_pieces, can_move, corners, has_started, idx, score') # <<<<<<<<<<<<<< + * __pyx_result = PlayerState.__new__(__pyx_type) + * if __pyx_state is not None: +*/ + __pyx_t_1 = __Pyx_CheckUnpickleChecksum(__pyx_v___pyx_checksum, 0x820c4ca, 0x920c0b5, 0x70188c3, __pyx_k_available_pieces_can_move_corner); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 6, __pyx_L1_error) + + /* "(tree fragment)":7 + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x820c4ca, 0x920c0b5, 0x70188c3, b'available_pieces, can_move, corners, has_started, idx, score') + * __pyx_result = PlayerState.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_PlayerState__set_state( __pyx_result, __pyx_state) +*/ + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v___pyx_type}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_new, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_v___pyx_result = __pyx_t_2; + __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x820c4ca, 0x920c0b5, 0x70188c3, b'available_pieces, can_move, corners, has_started, idx, score') + * __pyx_result = PlayerState.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PlayerState__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + __pyx_t_5 = (__pyx_v___pyx_state != ((PyObject*)Py_None)); + if (__pyx_t_5) { + + /* "(tree fragment)":9 + * __pyx_result = PlayerState.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_PlayerState__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_PlayerState__set_state(PlayerState __pyx_result, __pyx_state: tuple): +*/ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared 'not None'"); + __PYX_ERR(1, 9, __pyx_L1_error) + } + __pyx_t_2 = __pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_PlayerState__set_state(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)__pyx_v___pyx_result), __pyx_v___pyx_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x820c4ca, 0x920c0b5, 0x70188c3, b'available_pieces, can_move, corners, has_started, idx, score') + * __pyx_result = PlayerState.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_PlayerState__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_PlayerState__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_PlayerState__set_state(PlayerState __pyx_result, __pyx_state: tuple): + * __pyx_result.available_pieces = __pyx_state[0]; __pyx_result.can_move = __pyx_state[1]; __pyx_result.corners = __pyx_state[2]; __pyx_result.has_started = __pyx_state[3]; __pyx_result.idx = __pyx_state[4]; __pyx_result.score = __pyx_state[5] +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_PlayerState(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x820c4ca, 0x920c0b5, 0x70188c3, b'available_pieces, can_move, corners, has_started, idx, score') +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_PlayerState", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_PlayerState__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PlayerState__set_state(PlayerState __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result.available_pieces = __pyx_state[0]; __pyx_result.can_move = __pyx_state[1]; __pyx_result.corners = __pyx_state[2]; __pyx_result.has_started = __pyx_state[3]; __pyx_result.idx = __pyx_state[4]; __pyx_result.score = __pyx_state[5] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 6) +*/ + +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_PlayerState__set_state(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_PlayerState__set_state", 0); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_PlayerState__set_state(PlayerState __pyx_result, __pyx_state: tuple): + * __pyx_result.available_pieces = __pyx_state[0]; __pyx_result.can_move = __pyx_state[1]; __pyx_result.corners = __pyx_state[2]; __pyx_result.has_started = __pyx_state[3]; __pyx_result.idx = __pyx_state[4]; __pyx_result.score = __pyx_state[5] # <<<<<<<<<<<<<< + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 6) +*/ + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PySet_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("set", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->available_pieces); + __Pyx_DECREF(__pyx_v___pyx_result->available_pieces); + __pyx_v___pyx_result->available_pieces = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->can_move = __pyx_t_2; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PySet_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("set", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->corners); + __Pyx_DECREF(__pyx_v___pyx_result->corners); + __pyx_v___pyx_result->corners = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->has_started = __pyx_t_2; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->idx = __pyx_t_3; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 5, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->score = __pyx_t_3; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_PlayerState__set_state(PlayerState __pyx_result, __pyx_state: tuple): + * __pyx_result.available_pieces = __pyx_state[0]; __pyx_result.can_move = __pyx_state[1]; __pyx_result.corners = __pyx_state[2]; __pyx_result.has_started = __pyx_state[3]; __pyx_result.idx = __pyx_state[4]; __pyx_result.score = __pyx_state[5] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 6) # <<<<<<<<<<<<<< +*/ + __pyx_t_3 = __Pyx_UpdateUnpickledDict(((PyObject *)__pyx_v___pyx_result), __pyx_v___pyx_state, 6); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + + /* "(tree fragment)":11 + * __pyx_unpickle_PlayerState__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_PlayerState__set_state(PlayerState __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result.available_pieces = __pyx_state[0]; __pyx_result.can_move = __pyx_state[1]; __pyx_result.corners = __pyx_state[2]; __pyx_result.has_started = __pyx_state[3]; __pyx_result.idx = __pyx_state[4]; __pyx_result.score = __pyx_state[5] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 6) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_PlayerState__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_BlokusGame(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x2eba6e9, 0xec864e3, 0x3965e13, b'_action_moves, _actions_by_piece, _move_to_action, _starting_corners, board, board_size, corner_rule, current_player, game_over, num_players, piece_set, players, rounds') +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_13__pyx_unpickle_BlokusGame(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_10blokus_gym_4core_13blokus_cython_13__pyx_unpickle_BlokusGame = {"__pyx_unpickle_BlokusGame", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_13__pyx_unpickle_BlokusGame, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_10blokus_gym_4core_13blokus_cython_13__pyx_unpickle_BlokusGame(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_BlokusGame (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_type,&__pyx_mstate_global->__pyx_n_u_pyx_checksum,&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) __PYX_ERR(1, 4, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__pyx_unpickle_BlokusGame", 0) < (0)) __PYX_ERR(1, 4, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_BlokusGame", 1, 3, 3, i); __PYX_ERR(1, 4, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 4, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 4, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 4, __pyx_L3_error) + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyLong_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 4, __pyx_L3_error) + __pyx_v___pyx_state = ((PyObject*)values[2]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_BlokusGame", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 4, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_BlokusGame", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v___pyx_state), (&PyTuple_Type), 1, "__pyx_state", 1))) __PYX_ERR(1, 4, __pyx_L1_error) + __pyx_r = __pyx_pf_10blokus_gym_4core_13blokus_cython_12__pyx_unpickle_BlokusGame(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_10blokus_gym_4core_13blokus_cython_12__pyx_unpickle_BlokusGame(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_BlokusGame", 0); + + /* "(tree fragment)":6 + * def __pyx_unpickle_BlokusGame(__pyx_type, long __pyx_checksum, tuple __pyx_state): + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x2eba6e9, 0xec864e3, 0x3965e13, b'_action_moves, _actions_by_piece, _move_to_action, _starting_corners, board, board_size, corner_rule, current_player, game_over, num_players, piece_set, players, rounds') # <<<<<<<<<<<<<< + * __pyx_result = BlokusGame.__new__(__pyx_type) + * if __pyx_state is not None: +*/ + __pyx_t_1 = __Pyx_CheckUnpickleChecksum(__pyx_v___pyx_checksum, 0x2eba6e9, 0xec864e3, 0x3965e13, __pyx_k_action_moves__actions_by_piece); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 6, __pyx_L1_error) + + /* "(tree fragment)":7 + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x2eba6e9, 0xec864e3, 0x3965e13, b'_action_moves, _actions_by_piece, _move_to_action, _starting_corners, board, board_size, corner_rule, current_player, game_over, num_players, piece_set, players, rounds') + * __pyx_result = BlokusGame.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_BlokusGame__set_state( __pyx_result, __pyx_state) +*/ + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v___pyx_type}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_new, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_v___pyx_result = __pyx_t_2; + __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x2eba6e9, 0xec864e3, 0x3965e13, b'_action_moves, _actions_by_piece, _move_to_action, _starting_corners, board, board_size, corner_rule, current_player, game_over, num_players, piece_set, players, rounds') + * __pyx_result = BlokusGame.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_BlokusGame__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + __pyx_t_5 = (__pyx_v___pyx_state != ((PyObject*)Py_None)); + if (__pyx_t_5) { + + /* "(tree fragment)":9 + * __pyx_result = BlokusGame.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_BlokusGame__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_BlokusGame__set_state(BlokusGame __pyx_result, __pyx_state: tuple): +*/ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared 'not None'"); + __PYX_ERR(1, 9, __pyx_L1_error) + } + __pyx_t_2 = __pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_BlokusGame__set_state(((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)__pyx_v___pyx_result), __pyx_v___pyx_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x2eba6e9, 0xec864e3, 0x3965e13, b'_action_moves, _actions_by_piece, _move_to_action, _starting_corners, board, board_size, corner_rule, current_player, game_over, num_players, piece_set, players, rounds') + * __pyx_result = BlokusGame.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_BlokusGame__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_BlokusGame__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_BlokusGame__set_state(BlokusGame __pyx_result, __pyx_state: tuple): + * __pyx_result._action_moves = __pyx_state[0]; __pyx_result._actions_by_piece = __pyx_state[1]; __pyx_result._move_to_action = __pyx_state[2]; __pyx_result._starting_corners = __pyx_state[3]; __pyx_result.board = __pyx_state[4]; __pyx_result.board_size = __pyx_state[5]; __pyx_result.corner_rule = __pyx_state[6]; __pyx_result.current_player = __pyx_state[7]; __pyx_result.game_over = __pyx_state[8]; __pyx_result.num_players = __pyx_state[9]; __pyx_result.piece_set = __pyx_state[10]; __pyx_result.players = __pyx_state[11]; __pyx_result.rounds = __pyx_state[12] +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_BlokusGame(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x2eba6e9, 0xec864e3, 0x3965e13, b'_action_moves, _actions_by_piece, _move_to_action, _starting_corners, board, board_size, corner_rule, current_player, game_over, num_players, piece_set, players, rounds') +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_BlokusGame", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_BlokusGame__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_BlokusGame__set_state(BlokusGame __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result._action_moves = __pyx_state[0]; __pyx_result._actions_by_piece = __pyx_state[1]; __pyx_result._move_to_action = __pyx_state[2]; __pyx_result._starting_corners = __pyx_state[3]; __pyx_result.board = __pyx_state[4]; __pyx_result.board_size = __pyx_state[5]; __pyx_result.corner_rule = __pyx_state[6]; __pyx_result.current_player = __pyx_state[7]; __pyx_result.game_over = __pyx_state[8]; __pyx_result.num_players = __pyx_state[9]; __pyx_result.piece_set = __pyx_state[10]; __pyx_result.players = __pyx_state[11]; __pyx_result.rounds = __pyx_state[12] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 13) +*/ + +static PyObject *__pyx_f_10blokus_gym_4core_13blokus_cython___pyx_unpickle_BlokusGame__set_state(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_BlokusGame__set_state", 0); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_BlokusGame__set_state(BlokusGame __pyx_result, __pyx_state: tuple): + * __pyx_result._action_moves = __pyx_state[0]; __pyx_result._actions_by_piece = __pyx_state[1]; __pyx_result._move_to_action = __pyx_state[2]; __pyx_result._starting_corners = __pyx_state[3]; __pyx_result.board = __pyx_state[4]; __pyx_result.board_size = __pyx_state[5]; __pyx_result.corner_rule = __pyx_state[6]; __pyx_result.current_player = __pyx_state[7]; __pyx_result.game_over = __pyx_state[8]; __pyx_result.num_players = __pyx_state[9]; __pyx_result.piece_set = __pyx_state[10]; __pyx_result.players = __pyx_state[11]; __pyx_result.rounds = __pyx_state[12] # <<<<<<<<<<<<<< + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 13) +*/ + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_action_moves); + __Pyx_DECREF(__pyx_v___pyx_result->_action_moves); + __pyx_v___pyx_result->_action_moves = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 1, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_actions_by_piece); + __Pyx_DECREF(__pyx_v___pyx_result->_actions_by_piece); + __pyx_v___pyx_result->_actions_by_piece = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 2, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyDict_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("dict", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_move_to_action); + __Pyx_DECREF(__pyx_v___pyx_result->_move_to_action); + __pyx_v___pyx_result->_move_to_action = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 3, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->_starting_corners); + __Pyx_DECREF(__pyx_v___pyx_result->_starting_corners); + __pyx_v___pyx_result->_starting_corners = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 4, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); 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->board); + __Pyx_DECREF(__pyx_v___pyx_result->board); + __pyx_v___pyx_result->board = __pyx_t_1; + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 5, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->board_size = __pyx_t_2; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 6, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->corner_rule = __pyx_t_3; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 7, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->current_player = __pyx_t_2; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 8, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->game_over = __pyx_t_3; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 9, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->num_players = __pyx_t_2; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 10, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet))))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF((PyObject *)__pyx_v___pyx_result->piece_set); + __Pyx_DECREF((PyObject *)__pyx_v___pyx_result->piece_set); + __pyx_v___pyx_result->piece_set = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 11, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(PyList_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("list", __pyx_t_1))) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->players); + __Pyx_DECREF(__pyx_v___pyx_result->players); + __pyx_v___pyx_result->players = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 12, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v___pyx_result->rounds = __pyx_t_2; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_BlokusGame__set_state(BlokusGame __pyx_result, __pyx_state: tuple): + * __pyx_result._action_moves = __pyx_state[0]; __pyx_result._actions_by_piece = __pyx_state[1]; __pyx_result._move_to_action = __pyx_state[2]; __pyx_result._starting_corners = __pyx_state[3]; __pyx_result.board = __pyx_state[4]; __pyx_result.board_size = __pyx_state[5]; __pyx_result.corner_rule = __pyx_state[6]; __pyx_result.current_player = __pyx_state[7]; __pyx_result.game_over = __pyx_state[8]; __pyx_result.num_players = __pyx_state[9]; __pyx_result.piece_set = __pyx_state[10]; __pyx_result.players = __pyx_state[11]; __pyx_result.rounds = __pyx_state[12] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 13) # <<<<<<<<<<<<<< +*/ + __pyx_t_2 = __Pyx_UpdateUnpickledDict(((PyObject *)__pyx_v___pyx_result), __pyx_v___pyx_state, 13); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + + /* "(tree fragment)":11 + * __pyx_unpickle_BlokusGame__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_BlokusGame__set_state(BlokusGame __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result._action_moves = __pyx_state[0]; __pyx_result._actions_by_piece = __pyx_state[1]; __pyx_result._move_to_action = __pyx_state[2]; __pyx_result._starting_corners = __pyx_state[3]; __pyx_result.board = __pyx_state[4]; __pyx_result.board_size = __pyx_state[5]; __pyx_result.corner_rule = __pyx_state[6]; __pyx_result.current_player = __pyx_state[7]; __pyx_result.game_over = __pyx_state[8]; __pyx_result.num_players = __pyx_state[9]; __pyx_result.piece_set = __pyx_state[10]; __pyx_result.players = __pyx_state[11]; __pyx_result.rounds = __pyx_state[12] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 13) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("blokus_gym.core.blokus_cython.__pyx_unpickle_BlokusGame__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +/* #### Code section: module_exttypes ### */ +static struct __pyx_vtabstruct_10blokus_gym_4core_13blokus_cython_Board __pyx_vtable_10blokus_gym_4core_13blokus_cython_Board; + +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython_Board(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *p; + PyObject *o; + o = __Pyx_AllocateExtensionType(t, 0); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)o); + p->__pyx_vtab = __pyx_vtabptr_10blokus_gym_4core_13blokus_cython_Board; + p->_occupied_cache = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->grid.data = NULL; + p->grid.memview = NULL; + return o; +} + +static void __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_Board(PyObject *o) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_Board) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->_occupied_cache); + __PYX_XCLEAR_MEMVIEW(&p->grid, 1); + p->grid.memview = NULL; p->grid.data = NULL; + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif +} + +static int __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython_Board(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->_occupied_cache) { + e = (*v)(p->_occupied_cache, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_10blokus_gym_4core_13blokus_cython_Board(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *)o; + tmp = ((PyObject*)p->_occupied_cache); + p->_occupied_cache = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_5Board_size(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_4size_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_5Board_size(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_4size_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_5Board_grid(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_4grid_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_5Board_grid(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_4grid_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_5Board__occupied_cache(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_15_occupied_cache_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_5Board__occupied_cache(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_15_occupied_cache_3__set__(o, v); + } + else { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_15_occupied_cache_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_10blokus_gym_4core_13blokus_cython_Board[] = { + {"place", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_3place, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_2place}, + {"clear", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_5clear, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_4clear}, + {"is_empty", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_7is_empty, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_6is_empty}, + {"in_bounds", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_9in_bounds, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_8in_bounds}, + {"has_overlap", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_11has_overlap, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_10has_overlap}, + {"get_cell", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_13get_cell, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_12get_cell}, + {"get_player_squares", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_15get_player_squares, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_14get_player_squares}, + {"get_player_occupied", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_17get_player_occupied, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_16get_player_occupied}, + {"get_player_corners", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_19get_player_corners, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_18get_player_corners}, + {"get_occupied", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_21get_occupied, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_20get_occupied}, + {"is_full", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_23is_full, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_22is_full}, + {"coverage", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_25coverage, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_5Board_24coverage}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_27__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_29__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_10blokus_gym_4core_13blokus_cython_Board[] = { + {"size", __pyx_getprop_10blokus_gym_4core_13blokus_cython_5Board_size, __pyx_setprop_10blokus_gym_4core_13blokus_cython_5Board_size, 0, 0}, + {"grid", __pyx_getprop_10blokus_gym_4core_13blokus_cython_5Board_grid, __pyx_setprop_10blokus_gym_4core_13blokus_cython_5Board_grid, 0, 0}, + {"_occupied_cache", __pyx_getprop_10blokus_gym_4core_13blokus_cython_5Board__occupied_cache, __pyx_setprop_10blokus_gym_4core_13blokus_cython_5Board__occupied_cache, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_10blokus_gym_4core_13blokus_cython_Board_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_Board}, + {Py_tp_doc, (void *)PyDoc_STR("Cython-optimized Board class with static typing.\n \n Key optimizations:\n - Static typing eliminates Python interpreter overhead\n - Direct C-level array access instead of Python method calls\n - Precomputed bounds checking\n ")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_10blokus_gym_4core_13blokus_cython_Board}, + {Py_tp_clear, (void *)__pyx_tp_clear_10blokus_gym_4core_13blokus_cython_Board}, + {Py_tp_methods, (void *)__pyx_methods_10blokus_gym_4core_13blokus_cython_Board}, + {Py_tp_getset, (void *)__pyx_getsets_10blokus_gym_4core_13blokus_cython_Board}, + {Py_tp_init, (void *)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython_Board}, + {0, 0}, +}; +static PyType_Spec __pyx_type_10blokus_gym_4core_13blokus_cython_Board_spec = { + "blokus_gym.core.blokus_cython.Board", + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_10blokus_gym_4core_13blokus_cython_Board_slots, +}; +#else + +static PyTypeObject __pyx_type_10blokus_gym_4core_13blokus_cython_Board = { + PyVarObject_HEAD_INIT(0, 0) + "blokus_gym.core.blokus_cython.""Board", /*tp_name*/ + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_Board, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*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*/ + PyDoc_STR("Cython-optimized Board class with static typing.\n \n Key optimizations:\n - Static typing eliminates Python interpreter overhead\n - Direct C-level array access instead of Python method calls\n - Precomputed bounds checking\n "), /*tp_doc*/ + __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython_Board, /*tp_traverse*/ + __pyx_tp_clear_10blokus_gym_4core_13blokus_cython_Board, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_10blokus_gym_4core_13blokus_cython_Board, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_10blokus_gym_4core_13blokus_cython_Board, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_10blokus_gym_4core_13blokus_cython_5Board_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_10blokus_gym_4core_13blokus_cython_Board, /*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 CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython_Move(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + o = __Pyx_AllocateExtensionType(t, 0); + if (unlikely(!o)) return 0; + return o; +} + +static void __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_Move(PyObject *o) { + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_Move) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_4Move_piece_id(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_8piece_id_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_4Move_piece_id(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_8piece_id_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_4Move_orientation_id(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_14orientation_id_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_4Move_orientation_id(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_14orientation_id_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_4Move_x(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_1x_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_4Move_x(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_1x_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_4Move_y(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_1y_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_4Move_y(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_1y_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyMethodDef __pyx_methods_10blokus_gym_4core_13blokus_cython_Move[] = { + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_5__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_7__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_10blokus_gym_4core_13blokus_cython_Move[] = { + {"piece_id", __pyx_getprop_10blokus_gym_4core_13blokus_cython_4Move_piece_id, __pyx_setprop_10blokus_gym_4core_13blokus_cython_4Move_piece_id, 0, 0}, + {"orientation_id", __pyx_getprop_10blokus_gym_4core_13blokus_cython_4Move_orientation_id, __pyx_setprop_10blokus_gym_4core_13blokus_cython_4Move_orientation_id, 0, 0}, + {"x", __pyx_getprop_10blokus_gym_4core_13blokus_cython_4Move_x, __pyx_setprop_10blokus_gym_4core_13blokus_cython_4Move_x, 0, 0}, + {"y", __pyx_getprop_10blokus_gym_4core_13blokus_cython_4Move_y, __pyx_setprop_10blokus_gym_4core_13blokus_cython_4Move_y, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_10blokus_gym_4core_13blokus_cython_Move_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_Move}, + {Py_tp_repr, (void *)__pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_3__repr__}, + {Py_tp_doc, (void *)PyDoc_STR("A move in the game (piece, orientation, position).")}, + {Py_tp_methods, (void *)__pyx_methods_10blokus_gym_4core_13blokus_cython_Move}, + {Py_tp_getset, (void *)__pyx_getsets_10blokus_gym_4core_13blokus_cython_Move}, + {Py_tp_init, (void *)__pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython_Move}, + {0, 0}, +}; +static PyType_Spec __pyx_type_10blokus_gym_4core_13blokus_cython_Move_spec = { + "blokus_gym.core.blokus_cython.Move", + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE, + __pyx_type_10blokus_gym_4core_13blokus_cython_Move_slots, +}; +#else + +static PyTypeObject __pyx_type_10blokus_gym_4core_13blokus_cython_Move = { + PyVarObject_HEAD_INIT(0, 0) + "blokus_gym.core.blokus_cython.""Move", /*tp_name*/ + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_Move, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + __pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_3__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, /*tp_flags*/ + PyDoc_STR("A move in the game (piece, orientation, position)."), /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_10blokus_gym_4core_13blokus_cython_Move, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_10blokus_gym_4core_13blokus_cython_Move, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_10blokus_gym_4core_13blokus_cython_4Move_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_10blokus_gym_4core_13blokus_cython_Move, /*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 CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython_PieceOrientation(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *p; + PyObject *o; + o = __Pyx_AllocateExtensionType(t, 0); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)o); + p->squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->corners = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_PieceOrientation(PyObject *o) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_PieceOrientation) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->squares); + Py_CLEAR(p->corners); + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif +} + +static int __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython_PieceOrientation(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->squares) { + e = (*v)(p->squares, a); if (e) return e; + } + if (p->corners) { + e = (*v)(p->corners, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_10blokus_gym_4core_13blokus_cython_PieceOrientation(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation *)o; + tmp = ((PyObject*)p->squares); + p->squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->corners); + p->corners = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_16PieceOrientation_piece_id(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_8piece_id_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_16PieceOrientation_piece_id(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_8piece_id_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_16PieceOrientation_orientation_id(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_14orientation_id_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_16PieceOrientation_orientation_id(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_14orientation_id_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_16PieceOrientation_squares(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7squares_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_16PieceOrientation_squares(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7squares_3__set__(o, v); + } + else { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7squares_5__del__(o); + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_16PieceOrientation_corners(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7corners_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_16PieceOrientation_corners(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7corners_3__set__(o, v); + } + else { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_7corners_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_10blokus_gym_4core_13blokus_cython_PieceOrientation[] = { + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_10blokus_gym_4core_13blokus_cython_PieceOrientation[] = { + {"piece_id", __pyx_getprop_10blokus_gym_4core_13blokus_cython_16PieceOrientation_piece_id, __pyx_setprop_10blokus_gym_4core_13blokus_cython_16PieceOrientation_piece_id, 0, 0}, + {"orientation_id", __pyx_getprop_10blokus_gym_4core_13blokus_cython_16PieceOrientation_orientation_id, __pyx_setprop_10blokus_gym_4core_13blokus_cython_16PieceOrientation_orientation_id, 0, 0}, + {"squares", __pyx_getprop_10blokus_gym_4core_13blokus_cython_16PieceOrientation_squares, __pyx_setprop_10blokus_gym_4core_13blokus_cython_16PieceOrientation_squares, 0, 0}, + {"corners", __pyx_getprop_10blokus_gym_4core_13blokus_cython_16PieceOrientation_corners, __pyx_setprop_10blokus_gym_4core_13blokus_cython_16PieceOrientation_corners, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_10blokus_gym_4core_13blokus_cython_PieceOrientation_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_PieceOrientation}, + {Py_tp_doc, (void *)PyDoc_STR("A piece in a specific orientation (before placement on board).")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_10blokus_gym_4core_13blokus_cython_PieceOrientation}, + {Py_tp_clear, (void *)__pyx_tp_clear_10blokus_gym_4core_13blokus_cython_PieceOrientation}, + {Py_tp_methods, (void *)__pyx_methods_10blokus_gym_4core_13blokus_cython_PieceOrientation}, + {Py_tp_getset, (void *)__pyx_getsets_10blokus_gym_4core_13blokus_cython_PieceOrientation}, + {Py_tp_init, (void *)__pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython_PieceOrientation}, + {0, 0}, +}; +static PyType_Spec __pyx_type_10blokus_gym_4core_13blokus_cython_PieceOrientation_spec = { + "blokus_gym.core.blokus_cython.PieceOrientation", + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_10blokus_gym_4core_13blokus_cython_PieceOrientation_slots, +}; +#else + +static PyTypeObject __pyx_type_10blokus_gym_4core_13blokus_cython_PieceOrientation = { + PyVarObject_HEAD_INIT(0, 0) + "blokus_gym.core.blokus_cython.""PieceOrientation", /*tp_name*/ + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceOrientation), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_PieceOrientation, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*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*/ + PyDoc_STR("A piece in a specific orientation (before placement on board)."), /*tp_doc*/ + __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython_PieceOrientation, /*tp_traverse*/ + __pyx_tp_clear_10blokus_gym_4core_13blokus_cython_PieceOrientation, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_10blokus_gym_4core_13blokus_cython_PieceOrientation, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_10blokus_gym_4core_13blokus_cython_PieceOrientation, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_10blokus_gym_4core_13blokus_cython_16PieceOrientation_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_10blokus_gym_4core_13blokus_cython_PieceOrientation, /*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 CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython_Piece(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *p; + PyObject *o; + o = __Pyx_AllocateExtensionType(t, 0); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)o); + p->name = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->squares = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_Piece(PyObject *o) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_Piece) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->name); + Py_CLEAR(p->squares); + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif +} + +static int __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython_Piece(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->squares) { + e = (*v)(p->squares, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_10blokus_gym_4core_13blokus_cython_Piece(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)o; + tmp = ((PyObject*)p->squares); + p->squares = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_5Piece_size(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_4size_1__get__(o); +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_5Piece_name(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_4name_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_5Piece_name(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_4name_3__set__(o, v); + } + else { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_4name_5__del__(o); + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_5Piece_squares(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_7squares_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_5Piece_squares(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_7squares_3__set__(o, v); + } + else { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_7squares_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_10blokus_gym_4core_13blokus_cython_Piece[] = { + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_10blokus_gym_4core_13blokus_cython_Piece[] = { + {"size", __pyx_getprop_10blokus_gym_4core_13blokus_cython_5Piece_size, 0, 0, 0}, + {"name", __pyx_getprop_10blokus_gym_4core_13blokus_cython_5Piece_name, __pyx_setprop_10blokus_gym_4core_13blokus_cython_5Piece_name, 0, 0}, + {"squares", __pyx_getprop_10blokus_gym_4core_13blokus_cython_5Piece_squares, __pyx_setprop_10blokus_gym_4core_13blokus_cython_5Piece_squares, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_10blokus_gym_4core_13blokus_cython_Piece_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_Piece}, + {Py_tp_doc, (void *)PyDoc_STR("A polyomino piece defined by a set of (x, y) coordinates.")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_10blokus_gym_4core_13blokus_cython_Piece}, + {Py_tp_clear, (void *)__pyx_tp_clear_10blokus_gym_4core_13blokus_cython_Piece}, + {Py_tp_methods, (void *)__pyx_methods_10blokus_gym_4core_13blokus_cython_Piece}, + {Py_tp_getset, (void *)__pyx_getsets_10blokus_gym_4core_13blokus_cython_Piece}, + {Py_tp_init, (void *)__pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython_Piece}, + {0, 0}, +}; +static PyType_Spec __pyx_type_10blokus_gym_4core_13blokus_cython_Piece_spec = { + "blokus_gym.core.blokus_cython.Piece", + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_10blokus_gym_4core_13blokus_cython_Piece_slots, +}; +#else + +static PyTypeObject __pyx_type_10blokus_gym_4core_13blokus_cython_Piece = { + PyVarObject_HEAD_INIT(0, 0) + "blokus_gym.core.blokus_cython.""Piece", /*tp_name*/ + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_Piece, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*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*/ + PyDoc_STR("A polyomino piece defined by a set of (x, y) coordinates."), /*tp_doc*/ + __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython_Piece, /*tp_traverse*/ + __pyx_tp_clear_10blokus_gym_4core_13blokus_cython_Piece, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_10blokus_gym_4core_13blokus_cython_Piece, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_10blokus_gym_4core_13blokus_cython_Piece, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_10blokus_gym_4core_13blokus_cython_5Piece_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_10blokus_gym_4core_13blokus_cython_Piece, /*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 CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython_PieceSet(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *p; + PyObject *o; + o = __Pyx_AllocateExtensionType(t, 0); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)o); + p->pieces = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->piece_names = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->piece_id_map = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->orientations = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_PieceSet(PyObject *o) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_PieceSet) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->pieces); + Py_CLEAR(p->piece_names); + Py_CLEAR(p->piece_id_map); + Py_CLEAR(p->orientations); + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif +} + +static int __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython_PieceSet(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->pieces) { + e = (*v)(p->pieces, a); if (e) return e; + } + if (p->piece_names) { + e = (*v)(p->piece_names, a); if (e) return e; + } + if (p->piece_id_map) { + e = (*v)(p->piece_id_map, a); if (e) return e; + } + if (p->orientations) { + e = (*v)(p->orientations, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_10blokus_gym_4core_13blokus_cython_PieceSet(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)o; + tmp = ((PyObject*)p->pieces); + p->pieces = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->piece_names); + p->piece_names = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->piece_id_map); + p->piece_id_map = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->orientations); + p->orientations = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_8PieceSet_num_pieces(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_10num_pieces_1__get__(o); +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_8PieceSet_pieces(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_6pieces_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_8PieceSet_pieces(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_6pieces_3__set__(o, v); + } + else { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_6pieces_5__del__(o); + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_8PieceSet_piece_names(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_11piece_names_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_8PieceSet_piece_names(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_11piece_names_3__set__(o, v); + } + else { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_11piece_names_5__del__(o); + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_8PieceSet_piece_id_map(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_12piece_id_map_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_8PieceSet_piece_id_map(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_12piece_id_map_3__set__(o, v); + } + else { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_12piece_id_map_5__del__(o); + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_8PieceSet_orientations(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_12orientations_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_8PieceSet_orientations(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_12orientations_3__set__(o, v); + } + else { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_12orientations_5__del__(o); + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_8PieceSet_num_orientations(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_16num_orientations_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_8PieceSet_num_orientations(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_16num_orientations_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyMethodDef __pyx_methods_10blokus_gym_4core_13blokus_cython_PieceSet[] = { + {"get_orientations", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_3get_orientations, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"get_piece", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_5get_piece, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"get_piece_id", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_7get_piece_id, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_9__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_11__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_10blokus_gym_4core_13blokus_cython_PieceSet[] = { + {"num_pieces", __pyx_getprop_10blokus_gym_4core_13blokus_cython_8PieceSet_num_pieces, 0, 0, 0}, + {"pieces", __pyx_getprop_10blokus_gym_4core_13blokus_cython_8PieceSet_pieces, __pyx_setprop_10blokus_gym_4core_13blokus_cython_8PieceSet_pieces, 0, 0}, + {"piece_names", __pyx_getprop_10blokus_gym_4core_13blokus_cython_8PieceSet_piece_names, __pyx_setprop_10blokus_gym_4core_13blokus_cython_8PieceSet_piece_names, 0, 0}, + {"piece_id_map", __pyx_getprop_10blokus_gym_4core_13blokus_cython_8PieceSet_piece_id_map, __pyx_setprop_10blokus_gym_4core_13blokus_cython_8PieceSet_piece_id_map, 0, 0}, + {"orientations", __pyx_getprop_10blokus_gym_4core_13blokus_cython_8PieceSet_orientations, __pyx_setprop_10blokus_gym_4core_13blokus_cython_8PieceSet_orientations, 0, 0}, + {"num_orientations", __pyx_getprop_10blokus_gym_4core_13blokus_cython_8PieceSet_num_orientations, __pyx_setprop_10blokus_gym_4core_13blokus_cython_8PieceSet_num_orientations, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_10blokus_gym_4core_13blokus_cython_PieceSet_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_PieceSet}, + {Py_tp_doc, (void *)PyDoc_STR("A collection of pieces with pre-computed orientations.")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_10blokus_gym_4core_13blokus_cython_PieceSet}, + {Py_tp_clear, (void *)__pyx_tp_clear_10blokus_gym_4core_13blokus_cython_PieceSet}, + {Py_tp_methods, (void *)__pyx_methods_10blokus_gym_4core_13blokus_cython_PieceSet}, + {Py_tp_getset, (void *)__pyx_getsets_10blokus_gym_4core_13blokus_cython_PieceSet}, + {Py_tp_init, (void *)__pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython_PieceSet}, + {0, 0}, +}; +static PyType_Spec __pyx_type_10blokus_gym_4core_13blokus_cython_PieceSet_spec = { + "blokus_gym.core.blokus_cython.PieceSet", + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_10blokus_gym_4core_13blokus_cython_PieceSet_slots, +}; +#else + +static PyTypeObject __pyx_type_10blokus_gym_4core_13blokus_cython_PieceSet = { + PyVarObject_HEAD_INIT(0, 0) + "blokus_gym.core.blokus_cython.""PieceSet", /*tp_name*/ + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_PieceSet, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*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*/ + PyDoc_STR("A collection of pieces with pre-computed orientations."), /*tp_doc*/ + __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython_PieceSet, /*tp_traverse*/ + __pyx_tp_clear_10blokus_gym_4core_13blokus_cython_PieceSet, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_10blokus_gym_4core_13blokus_cython_PieceSet, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_10blokus_gym_4core_13blokus_cython_PieceSet, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_10blokus_gym_4core_13blokus_cython_8PieceSet_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_10blokus_gym_4core_13blokus_cython_PieceSet, /*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 CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython_PlayerState(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *p; + PyObject *o; + o = __Pyx_AllocateExtensionType(t, 0); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)o); + p->available_pieces = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->corners = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_PlayerState(PyObject *o) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_PlayerState) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->available_pieces); + Py_CLEAR(p->corners); + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif +} + +static int __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython_PlayerState(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->available_pieces) { + e = (*v)(p->available_pieces, a); if (e) return e; + } + if (p->corners) { + e = (*v)(p->corners, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_10blokus_gym_4core_13blokus_cython_PlayerState(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState *)o; + tmp = ((PyObject*)p->available_pieces); + p->available_pieces = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->corners); + p->corners = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_11PlayerState_idx(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_3idx_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_11PlayerState_idx(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_3idx_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_11PlayerState_available_pieces(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_16available_pieces_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_11PlayerState_available_pieces(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_16available_pieces_3__set__(o, v); + } + else { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_16available_pieces_5__del__(o); + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_11PlayerState_corners(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_7corners_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_11PlayerState_corners(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_7corners_3__set__(o, v); + } + else { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_7corners_5__del__(o); + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_11PlayerState_score(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_5score_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_11PlayerState_score(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_5score_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_11PlayerState_has_started(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_11has_started_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_11PlayerState_has_started(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_11has_started_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_11PlayerState_can_move(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_8can_move_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_11PlayerState_can_move(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_8can_move_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyMethodDef __pyx_methods_10blokus_gym_4core_13blokus_cython_PlayerState[] = { + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_3__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_5__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_10blokus_gym_4core_13blokus_cython_PlayerState[] = { + {"idx", __pyx_getprop_10blokus_gym_4core_13blokus_cython_11PlayerState_idx, __pyx_setprop_10blokus_gym_4core_13blokus_cython_11PlayerState_idx, 0, 0}, + {"available_pieces", __pyx_getprop_10blokus_gym_4core_13blokus_cython_11PlayerState_available_pieces, __pyx_setprop_10blokus_gym_4core_13blokus_cython_11PlayerState_available_pieces, 0, 0}, + {"corners", __pyx_getprop_10blokus_gym_4core_13blokus_cython_11PlayerState_corners, __pyx_setprop_10blokus_gym_4core_13blokus_cython_11PlayerState_corners, 0, 0}, + {"score", __pyx_getprop_10blokus_gym_4core_13blokus_cython_11PlayerState_score, __pyx_setprop_10blokus_gym_4core_13blokus_cython_11PlayerState_score, 0, 0}, + {"has_started", __pyx_getprop_10blokus_gym_4core_13blokus_cython_11PlayerState_has_started, __pyx_setprop_10blokus_gym_4core_13blokus_cython_11PlayerState_has_started, 0, 0}, + {"can_move", __pyx_getprop_10blokus_gym_4core_13blokus_cython_11PlayerState_can_move, __pyx_setprop_10blokus_gym_4core_13blokus_cython_11PlayerState_can_move, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_10blokus_gym_4core_13blokus_cython_PlayerState_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_PlayerState}, + {Py_tp_doc, (void *)PyDoc_STR("State for a single player.")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_10blokus_gym_4core_13blokus_cython_PlayerState}, + {Py_tp_clear, (void *)__pyx_tp_clear_10blokus_gym_4core_13blokus_cython_PlayerState}, + {Py_tp_methods, (void *)__pyx_methods_10blokus_gym_4core_13blokus_cython_PlayerState}, + {Py_tp_getset, (void *)__pyx_getsets_10blokus_gym_4core_13blokus_cython_PlayerState}, + {Py_tp_init, (void *)__pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython_PlayerState}, + {0, 0}, +}; +static PyType_Spec __pyx_type_10blokus_gym_4core_13blokus_cython_PlayerState_spec = { + "blokus_gym.core.blokus_cython.PlayerState", + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_10blokus_gym_4core_13blokus_cython_PlayerState_slots, +}; +#else + +static PyTypeObject __pyx_type_10blokus_gym_4core_13blokus_cython_PlayerState = { + PyVarObject_HEAD_INIT(0, 0) + "blokus_gym.core.blokus_cython.""PlayerState", /*tp_name*/ + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PlayerState), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_PlayerState, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*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*/ + PyDoc_STR("State for a single player."), /*tp_doc*/ + __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython_PlayerState, /*tp_traverse*/ + __pyx_tp_clear_10blokus_gym_4core_13blokus_cython_PlayerState, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_10blokus_gym_4core_13blokus_cython_PlayerState, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_10blokus_gym_4core_13blokus_cython_PlayerState, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_10blokus_gym_4core_13blokus_cython_11PlayerState_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_10blokus_gym_4core_13blokus_cython_PlayerState, /*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 CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_10blokus_gym_4core_13blokus_cython_BlokusGame __pyx_vtable_10blokus_gym_4core_13blokus_cython_BlokusGame; + +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython_BlokusGame(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *p; + PyObject *o; + o = __Pyx_AllocateExtensionType(t, 0); + if (unlikely(!o)) return 0; + p = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)o); + p->__pyx_vtab = __pyx_vtabptr_10blokus_gym_4core_13blokus_cython_BlokusGame; + p->piece_set = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)Py_None); Py_INCREF(Py_None); + p->board = Py_None; Py_INCREF(Py_None); + p->players = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_action_moves = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_move_to_action = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_actions_by_piece = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_starting_corners = ((PyObject*)Py_None); Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_BlokusGame(PyObject *o) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_BlokusGame) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->piece_set); + Py_CLEAR(p->board); + Py_CLEAR(p->players); + Py_CLEAR(p->_action_moves); + Py_CLEAR(p->_move_to_action); + Py_CLEAR(p->_actions_by_piece); + Py_CLEAR(p->_starting_corners); + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif +} + +static int __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython_BlokusGame(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->piece_set) { + e = (*v)(((PyObject *)p->piece_set), a); if (e) return e; + } + if (p->board) { + e = (*v)(p->board, a); if (e) return e; + } + if (p->players) { + e = (*v)(p->players, a); if (e) return e; + } + if (p->_action_moves) { + e = (*v)(p->_action_moves, a); if (e) return e; + } + if (p->_move_to_action) { + e = (*v)(p->_move_to_action, a); if (e) return e; + } + if (p->_actions_by_piece) { + e = (*v)(p->_actions_by_piece, a); if (e) return e; + } + if (p->_starting_corners) { + e = (*v)(p->_starting_corners, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_10blokus_gym_4core_13blokus_cython_BlokusGame(PyObject *o) { + PyObject* tmp; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *)o; + tmp = ((PyObject*)p->piece_set); + p->piece_set = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_PieceSet *)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->board); + p->board = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->players); + p->players = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_action_moves); + p->_action_moves = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_move_to_action); + p->_move_to_action = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_actions_by_piece); + p->_actions_by_piece = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_starting_corners); + p->_starting_corners = ((PyObject*)Py_None); Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_num_actions(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_11num_actions_1__get__(o); +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_board_size(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_10board_size_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_board_size(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_10board_size_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_piece_set(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_9piece_set_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_piece_set(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_9piece_set_3__set__(o, v); + } + else { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_9piece_set_5__del__(o); + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_num_players(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_11num_players_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_num_players(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_11num_players_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_corner_rule(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_11corner_rule_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_corner_rule(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_11corner_rule_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_board(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_5board_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_board(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_5board_3__set__(o, v); + } + else { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_5board_5__del__(o); + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_players(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_7players_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_players(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_7players_3__set__(o, v); + } + else { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_7players_5__del__(o); + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_current_player(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_14current_player_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_current_player(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_14current_player_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_rounds(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_6rounds_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_rounds(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_6rounds_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_game_over(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_9game_over_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_game_over(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_9game_over_3__set__(o, v); + } + else { + PyErr_SetString(PyExc_NotImplementedError, "__del__"); + return -1; + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame__action_moves(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_13_action_moves_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame__action_moves(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_13_action_moves_3__set__(o, v); + } + else { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_13_action_moves_5__del__(o); + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame__move_to_action(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_15_move_to_action_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame__move_to_action(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_15_move_to_action_3__set__(o, v); + } + else { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_15_move_to_action_5__del__(o); + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame__actions_by_piece(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_actions_by_piece_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame__actions_by_piece(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_actions_by_piece_3__set__(o, v); + } + else { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_actions_by_piece_5__del__(o); + } +} + +static PyObject *__pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame__starting_corners(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_starting_corners_1__get__(o); +} + +static int __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame__starting_corners(PyObject *o, PyObject *v, CYTHON_UNUSED void *x) { + if (v) { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_starting_corners_3__set__(o, v); + } + else { + return __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17_starting_corners_5__del__(o); + } +} + +static PyMethodDef __pyx_methods_10blokus_gym_4core_13blokus_cython_BlokusGame[] = { + {"get_move", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_3get_move, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"get_action", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_5get_action, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"reset", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_7reset, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_6reset}, + {"apply_move", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_15apply_move, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_14apply_move}, + {"play_move", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_17play_move, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_16play_move}, + {"next_player", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_19next_player, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_18next_player}, + {"_check_game_over", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_21_check_game_over, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_20_check_game_over}, + {"get_state", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_23get_state, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_22get_state}, + {"copy", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_25copy, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_10blokus_gym_4core_13blokus_cython_10BlokusGame_24copy}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_27__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_29__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_10blokus_gym_4core_13blokus_cython_BlokusGame[] = { + {"num_actions", __pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_num_actions, 0, 0, 0}, + {"board_size", __pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_board_size, __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_board_size, 0, 0}, + {"piece_set", __pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_piece_set, __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_piece_set, 0, 0}, + {"num_players", __pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_num_players, __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_num_players, 0, 0}, + {"corner_rule", __pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_corner_rule, __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_corner_rule, 0, 0}, + {"board", __pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_board, __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_board, 0, 0}, + {"players", __pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_players, __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_players, 0, 0}, + {"current_player", __pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_current_player, __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_current_player, 0, 0}, + {"rounds", __pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_rounds, __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_rounds, 0, 0}, + {"game_over", __pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_game_over, __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame_game_over, 0, 0}, + {"_action_moves", __pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame__action_moves, __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame__action_moves, 0, 0}, + {"_move_to_action", __pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame__move_to_action, __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame__move_to_action, 0, 0}, + {"_actions_by_piece", __pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame__actions_by_piece, __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame__actions_by_piece, 0, 0}, + {"_starting_corners", __pyx_getprop_10blokus_gym_4core_13blokus_cython_10BlokusGame__starting_corners, __pyx_setprop_10blokus_gym_4core_13blokus_cython_10BlokusGame__starting_corners, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_10blokus_gym_4core_13blokus_cython_BlokusGame_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_BlokusGame}, + {Py_tp_doc, (void *)PyDoc_STR("Cython-optimized Blokus game engine.")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_10blokus_gym_4core_13blokus_cython_BlokusGame}, + {Py_tp_clear, (void *)__pyx_tp_clear_10blokus_gym_4core_13blokus_cython_BlokusGame}, + {Py_tp_methods, (void *)__pyx_methods_10blokus_gym_4core_13blokus_cython_BlokusGame}, + {Py_tp_getset, (void *)__pyx_getsets_10blokus_gym_4core_13blokus_cython_BlokusGame}, + {Py_tp_init, (void *)__pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_1__init__}, + {Py_tp_new, (void *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython_BlokusGame}, + {0, 0}, +}; +static PyType_Spec __pyx_type_10blokus_gym_4core_13blokus_cython_BlokusGame_spec = { + "blokus_gym.core.blokus_cython.BlokusGame", + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type_10blokus_gym_4core_13blokus_cython_BlokusGame_slots, +}; +#else + +static PyTypeObject __pyx_type_10blokus_gym_4core_13blokus_cython_BlokusGame = { + PyVarObject_HEAD_INIT(0, 0) + "blokus_gym.core.blokus_cython.""BlokusGame", /*tp_name*/ + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython_BlokusGame, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*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*/ + PyDoc_STR("Cython-optimized Blokus game engine."), /*tp_doc*/ + __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython_BlokusGame, /*tp_traverse*/ + __pyx_tp_clear_10blokus_gym_4core_13blokus_cython_BlokusGame, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_10blokus_gym_4core_13blokus_cython_BlokusGame, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_10blokus_gym_4core_13blokus_cython_BlokusGame, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_pw_10blokus_gym_4core_13blokus_cython_10BlokusGame_1__init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_10blokus_gym_4core_13blokus_cython_BlokusGame, /*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 CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr > 0) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(t, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr)))) + { + o = (PyObject*)__pyx_mstate_global->__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr[--__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr]; + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(Py_TYPE(o)); + #endif + memset(o, 0, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr)); + #if CYTHON_COMPILING_IN_LIMITED_API + (void) PyObject_Init(o, t); + #else + (void) PyObject_INIT(o, t); + #endif + PyObject_GC_Track(o); + } else + #endif + { + o = __Pyx_AllocateExtensionType(t, 1); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr(PyObject *o) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_genexpr_arg_0); + Py_CLEAR(p->__pyx_v_o); + Py_CLEAR(p->__pyx_t_0); + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr < 8) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(Py_TYPE(o), __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr)))) + { + __pyx_mstate_global->__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr[__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr++] = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr *)o); + } else + #endif + { + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif + } +} + +static int __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->__pyx_genexpr_arg_0) { + e = (*v)(p->__pyx_genexpr_arg_0, a); if (e) return e; + } + if (p->__pyx_v_o) { + e = (*v)(p->__pyx_v_o, a); if (e) return e; + } + if (p->__pyx_t_0) { + e = (*v)(p->__pyx_t_0, a); if (e) return e; + } + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr}, + {Py_tp_new, (void *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr_spec = { + "blokus_gym.core.blokus_cython.__pyx_scope_struct__genexpr", + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, + __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr_slots, +}; +#else + +static PyTypeObject __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "blokus_gym.core.blokus_cython.""__pyx_scope_struct__genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*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_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr, /*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 CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr > 0) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(t, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr)))) + { + o = (PyObject*)__pyx_mstate_global->__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr[--__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr]; + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(Py_TYPE(o)); + #endif + memset(o, 0, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr)); + #if CYTHON_COMPILING_IN_LIMITED_API + (void) PyObject_Init(o, t); + #else + (void) PyObject_INIT(o, t); + #endif + PyObject_GC_Track(o); + } else + #endif + { + o = __Pyx_AllocateExtensionType(t, 1); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr(PyObject *o) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_genexpr_arg_0); + Py_CLEAR(p->__pyx_v__); + Py_CLEAR(p->__pyx_v_x); + Py_CLEAR(p->__pyx_t_0); + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr < 8) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(Py_TYPE(o), __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr)))) + { + __pyx_mstate_global->__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr[__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr++] = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr *)o); + } else + #endif + { + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif + } +} + +static int __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->__pyx_genexpr_arg_0) { + e = (*v)(p->__pyx_genexpr_arg_0, a); if (e) return e; + } + if (p->__pyx_v__) { + e = (*v)(p->__pyx_v__, a); if (e) return e; + } + if (p->__pyx_v_x) { + e = (*v)(p->__pyx_v_x, a); if (e) return e; + } + if (p->__pyx_t_0) { + e = (*v)(p->__pyx_t_0, a); if (e) return e; + } + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr}, + {Py_tp_new, (void *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr_spec = { + "blokus_gym.core.blokus_cython.__pyx_scope_struct_1_genexpr", + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, + __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr_slots, +}; +#else + +static PyTypeObject __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "blokus_gym.core.blokus_cython.""__pyx_scope_struct_1_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*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_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr, /*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 CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr > 0) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(t, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr)))) + { + o = (PyObject*)__pyx_mstate_global->__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr[--__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr]; + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(Py_TYPE(o)); + #endif + memset(o, 0, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr)); + #if CYTHON_COMPILING_IN_LIMITED_API + (void) PyObject_Init(o, t); + #else + (void) PyObject_INIT(o, t); + #endif + PyObject_GC_Track(o); + } else + #endif + { + o = __Pyx_AllocateExtensionType(t, 1); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr(PyObject *o) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_genexpr_arg_0); + Py_CLEAR(p->__pyx_v__); + Py_CLEAR(p->__pyx_v_y); + Py_CLEAR(p->__pyx_t_0); + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr < 8) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(Py_TYPE(o), __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr)))) + { + __pyx_mstate_global->__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr[__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr++] = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr *)o); + } else + #endif + { + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif + } +} + +static int __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->__pyx_genexpr_arg_0) { + e = (*v)(p->__pyx_genexpr_arg_0, a); if (e) return e; + } + if (p->__pyx_v__) { + e = (*v)(p->__pyx_v__, a); if (e) return e; + } + if (p->__pyx_v_y) { + e = (*v)(p->__pyx_v_y, a); if (e) return e; + } + if (p->__pyx_t_0) { + e = (*v)(p->__pyx_t_0, a); if (e) return e; + } + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr}, + {Py_tp_new, (void *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr_spec = { + "blokus_gym.core.blokus_cython.__pyx_scope_struct_2_genexpr", + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, + __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr_slots, +}; +#else + +static PyTypeObject __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "blokus_gym.core.blokus_cython.""__pyx_scope_struct_2_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*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_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr, /*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 CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr > 0) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(t, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr)))) + { + o = (PyObject*)__pyx_mstate_global->__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr[--__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr]; + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(Py_TYPE(o)); + #endif + memset(o, 0, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr)); + #if CYTHON_COMPILING_IN_LIMITED_API + (void) PyObject_Init(o, t); + #else + (void) PyObject_INIT(o, t); + #endif + PyObject_GC_Track(o); + } else + #endif + { + o = __Pyx_AllocateExtensionType(t, 1); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr(PyObject *o) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_genexpr_arg_0); + Py_CLEAR(p->__pyx_v__); + Py_CLEAR(p->__pyx_v_x); + Py_CLEAR(p->__pyx_t_0); + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr < 8) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(Py_TYPE(o), __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr)))) + { + __pyx_mstate_global->__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr[__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr++] = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr *)o); + } else + #endif + { + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif + } +} + +static int __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->__pyx_genexpr_arg_0) { + e = (*v)(p->__pyx_genexpr_arg_0, a); if (e) return e; + } + if (p->__pyx_v__) { + e = (*v)(p->__pyx_v__, a); if (e) return e; + } + if (p->__pyx_v_x) { + e = (*v)(p->__pyx_v_x, a); if (e) return e; + } + if (p->__pyx_t_0) { + e = (*v)(p->__pyx_t_0, a); if (e) return e; + } + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr}, + {Py_tp_new, (void *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr_spec = { + "blokus_gym.core.blokus_cython.__pyx_scope_struct_3_genexpr", + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, + __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr_slots, +}; +#else + +static PyTypeObject __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "blokus_gym.core.blokus_cython.""__pyx_scope_struct_3_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*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_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr, /*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 CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr > 0) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(t, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr)))) + { + o = (PyObject*)__pyx_mstate_global->__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr[--__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr]; + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(Py_TYPE(o)); + #endif + memset(o, 0, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr)); + #if CYTHON_COMPILING_IN_LIMITED_API + (void) PyObject_Init(o, t); + #else + (void) PyObject_INIT(o, t); + #endif + PyObject_GC_Track(o); + } else + #endif + { + o = __Pyx_AllocateExtensionType(t, 1); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr(PyObject *o) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_genexpr_arg_0); + Py_CLEAR(p->__pyx_v__); + Py_CLEAR(p->__pyx_v_y); + Py_CLEAR(p->__pyx_t_0); + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr < 8) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(Py_TYPE(o), __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr)))) + { + __pyx_mstate_global->__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr[__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr++] = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr *)o); + } else + #endif + { + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif + } +} + +static int __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->__pyx_genexpr_arg_0) { + e = (*v)(p->__pyx_genexpr_arg_0, a); if (e) return e; + } + if (p->__pyx_v__) { + e = (*v)(p->__pyx_v__, a); if (e) return e; + } + if (p->__pyx_v_y) { + e = (*v)(p->__pyx_v_y, a); if (e) return e; + } + if (p->__pyx_t_0) { + e = (*v)(p->__pyx_t_0, a); if (e) return e; + } + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr}, + {Py_tp_new, (void *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr_spec = { + "blokus_gym.core.blokus_cython.__pyx_scope_struct_4_genexpr", + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, + __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr_slots, +}; +#else + +static PyTypeObject __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "blokus_gym.core.blokus_cython.""__pyx_scope_struct_4_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*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_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr, /*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 CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr > 0) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(t, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr)))) + { + o = (PyObject*)__pyx_mstate_global->__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr[--__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr]; + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(Py_TYPE(o)); + #endif + memset(o, 0, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr)); + #if CYTHON_COMPILING_IN_LIMITED_API + (void) PyObject_Init(o, t); + #else + (void) PyObject_INIT(o, t); + #endif + PyObject_GC_Track(o); + } else + #endif + { + o = __Pyx_AllocateExtensionType(t, 1); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr(PyObject *o) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_genexpr_arg_0); + Py_CLEAR(p->__pyx_v_p); + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr < 8) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(Py_TYPE(o), __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr)))) + { + __pyx_mstate_global->__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr[__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr++] = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr *)o); + } else + #endif + { + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif + } +} + +static int __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->__pyx_genexpr_arg_0) { + e = (*v)(p->__pyx_genexpr_arg_0, a); if (e) return e; + } + if (p->__pyx_v_p) { + e = (*v)(p->__pyx_v_p, a); if (e) return e; + } + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr}, + {Py_tp_new, (void *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr_spec = { + "blokus_gym.core.blokus_cython.__pyx_scope_struct_5_genexpr", + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, + __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr_slots, +}; +#else + +static PyTypeObject __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "blokus_gym.core.blokus_cython.""__pyx_scope_struct_5_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*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_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr, /*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 CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr > 0) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(t, __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr)))) + { + o = (PyObject*)__pyx_mstate_global->__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr[--__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr]; + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(Py_TYPE(o)); + #endif + memset(o, 0, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr)); + #if CYTHON_COMPILING_IN_LIMITED_API + (void) PyObject_Init(o, t); + #else + (void) PyObject_INIT(o, t); + #endif + PyObject_GC_Track(o); + } else + #endif + { + o = __Pyx_AllocateExtensionType(t, 1); + if (unlikely(!o)) return 0; + } + return o; +} + +static void __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr(PyObject *o) { + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->__pyx_genexpr_arg_0); + Py_CLEAR(p->__pyx_v_p); + #if CYTHON_USE_FREELISTS + if (likely((int)(__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr < 8) & __PYX_CHECK_FINAL_TYPE_FOR_FREELISTS(Py_TYPE(o), __pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr, sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr)))) + { + __pyx_mstate_global->__pyx_freelist_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr[__pyx_mstate_global->__pyx_freecount_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr++] = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr *)o); + } else + #endif + { + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif + } +} + +static int __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr *p = (struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->__pyx_genexpr_arg_0) { + e = (*v)(p->__pyx_genexpr_arg_0, a); if (e) return e; + } + if (p->__pyx_v_p) { + e = (*v)(p->__pyx_v_p, a); if (e) return e; + } + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr}, + {Py_tp_new, (void *)__pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr}, + {0, 0}, +}; +static PyType_Spec __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr_spec = { + "blokus_gym.core.blokus_cython.__pyx_scope_struct_6_genexpr", + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, + __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr_slots, +}; +#else + +static PyTypeObject __pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr = { + PyVarObject_HEAD_INIT(0, 0) + "blokus_gym.core.blokus_cython.""__pyx_scope_struct_6_genexpr", /*tp_name*/ + sizeof(struct __pyx_obj_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*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_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr, /*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 CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +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; + o = __Pyx_AllocateExtensionType(t, 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(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_array) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_DeallocKeepAliveBegin(o); + __pyx_array___dealloc__(o); + __Pyx_DeallocKeepAliveEnd(o); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->mode); + Py_CLEAR(p->_format); + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif +} + +static PyObject *__pyx_sq_item_array(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyLong_FromSsize_t(i); if(!x) return 0; + #if CYTHON_USE_TYPE_SLOTS || (!CYTHON_USE_TYPE_SPECS && __PYX_LIMITED_VERSION_HEX < 0x030A0000) + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + #else + r = ((binaryfunc)PyType_GetSlot(Py_TYPE(o), Py_mp_subscript))(o, x); + #endif + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_array(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_array___setitem__(o, i, v); + } + else { + __Pyx_TypeName o_type_name; + o_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(o)); + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by " __Pyx_FMT_TYPENAME, o_type_name); + __Pyx_DECREF_TypeName(o_type_name); + return -1; + } +} + +static PyObject *__pyx_tp_getattro_array(PyObject *o, PyObject *n) { + PyObject *v = PyObject_GenericGetAttr(o, n); + if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + v = __pyx_array___getattr__(o, n); + } + return v; +} + +static PyObject *__pyx_getprop___pyx_array_memview(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(o); +} + +static PyMethodDef __pyx_methods_array[] = { + {"__getattr__", (PyCFunction)__pyx_array___getattr__, METH_O|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_array_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_array_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_array[] = { + {"memview", __pyx_getprop___pyx_array_memview, 0, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +#if !CYTHON_COMPILING_IN_LIMITED_API + +static PyBufferProcs __pyx_tp_as_buffer_array = { + __pyx_array_getbuffer, /*bf_getbuffer*/ + 0, /*bf_releasebuffer*/ +}; +#endif +static PyType_Slot __pyx_type___pyx_array_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_array}, + {Py_sq_length, (void *)__pyx_array___len__}, + {Py_sq_item, (void *)__pyx_sq_item_array}, + {Py_mp_length, (void *)__pyx_array___len__}, + {Py_mp_subscript, (void *)__pyx_array___getitem__}, + {Py_mp_ass_subscript, (void *)__pyx_mp_ass_subscript_array}, + {Py_tp_getattro, (void *)__pyx_tp_getattro_array}, + #if defined(Py_bf_getbuffer) + {Py_bf_getbuffer, (void *)__pyx_array_getbuffer}, + #endif + {Py_tp_methods, (void *)__pyx_methods_array}, + {Py_tp_getset, (void *)__pyx_getsets_array}, + {Py_tp_new, (void *)__pyx_tp_new_array}, + {0, 0}, +}; +static PyType_Spec __pyx_type___pyx_array_spec = { + "blokus_gym.core.blokus_cython.array", + sizeof(struct __pyx_array_obj), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_SEQUENCE, + __pyx_type___pyx_array_slots, +}; +#else + +static PySequenceMethods __pyx_tp_as_sequence_array = { + __pyx_array___len__, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_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 = { + __pyx_array_getbuffer, /*bf_getbuffer*/ + 0, /*bf_releasebuffer*/ +}; + +static PyTypeObject __pyx_type___pyx_array = { + PyVarObject_HEAD_INIT(0, 0) + "blokus_gym.core.blokus_cython.""array", /*tp_name*/ + sizeof(struct __pyx_array_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_array, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 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|Py_TPFLAGS_SEQUENCE, /*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*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 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 CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_MemviewEnum_obj *p; + PyObject *o; + o = __Pyx_AllocateExtensionType(t, 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(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_Enum) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->name); + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif +} + +static int __pyx_tp_traverse_Enum(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + 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)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_MemviewEnum_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_MemviewEnum_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type___pyx_MemviewEnum_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_Enum}, + {Py_tp_repr, (void *)__pyx_MemviewEnum___repr__}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_Enum}, + {Py_tp_clear, (void *)__pyx_tp_clear_Enum}, + {Py_tp_methods, (void *)__pyx_methods_Enum}, + {Py_tp_init, (void *)__pyx_MemviewEnum___init__}, + {Py_tp_new, (void *)__pyx_tp_new_Enum}, + {0, 0}, +}; +static PyType_Spec __pyx_type___pyx_MemviewEnum_spec = { + "blokus_gym.core.blokus_cython.Enum", + sizeof(struct __pyx_MemviewEnum_obj), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type___pyx_MemviewEnum_slots, +}; +#else + +static PyTypeObject __pyx_type___pyx_MemviewEnum = { + PyVarObject_HEAD_INIT(0, 0) + "blokus_gym.core.blokus_cython.""Enum", /*tp_name*/ + sizeof(struct __pyx_MemviewEnum_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_Enum, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + __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*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __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 CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_memoryview __pyx_vtable_memoryview; + +static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_memoryview_obj *p; + PyObject *o; + o = __Pyx_AllocateExtensionType(t, 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->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(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_memoryview) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_DeallocKeepAliveBegin(o); + __pyx_memoryview___dealloc__(o); + __Pyx_DeallocKeepAliveEnd(o); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->obj); + Py_CLEAR(p->_size); + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif +} + +static int __pyx_tp_traverse_memoryview(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + 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->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); + Py_CLEAR(p->view.obj); + return 0; +} + +static PyObject *__pyx_sq_item_memoryview(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyLong_FromSsize_t(i); if(!x) return 0; + #if CYTHON_USE_TYPE_SLOTS || (!CYTHON_USE_TYPE_SPECS && __PYX_LIMITED_VERSION_HEX < 0x030A0000) + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + #else + r = ((binaryfunc)PyType_GetSlot(Py_TYPE(o), Py_mp_subscript))(o, x); + #endif + 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 { + __Pyx_TypeName o_type_name; + o_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(o)); + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by " __Pyx_FMT_TYPENAME, o_type_name); + __Pyx_DECREF_TypeName(o_type_name); + return -1; + } +} + +static PyObject *__pyx_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)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_is_c_contig, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"is_f_contig", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_is_f_contig, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"copy", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_copy, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"copy_fortran", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_copy_fortran, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryview_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryview_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_memoryview[] = { + {"T", __pyx_getprop___pyx_memoryview_T, 0, 0, 0}, + {"base", __pyx_getprop___pyx_memoryview_base, 0, 0, 0}, + {"shape", __pyx_getprop___pyx_memoryview_shape, 0, 0, 0}, + {"strides", __pyx_getprop___pyx_memoryview_strides, 0, 0, 0}, + {"suboffsets", __pyx_getprop___pyx_memoryview_suboffsets, 0, 0, 0}, + {"ndim", __pyx_getprop___pyx_memoryview_ndim, 0, 0, 0}, + {"itemsize", __pyx_getprop___pyx_memoryview_itemsize, 0, 0, 0}, + {"nbytes", __pyx_getprop___pyx_memoryview_nbytes, 0, 0, 0}, + {"size", __pyx_getprop___pyx_memoryview_size, 0, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +#if !CYTHON_COMPILING_IN_LIMITED_API + +static PyBufferProcs __pyx_tp_as_buffer_memoryview = { + __pyx_memoryview_getbuffer, /*bf_getbuffer*/ + 0, /*bf_releasebuffer*/ +}; +#endif +static PyType_Slot __pyx_type___pyx_memoryview_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_memoryview}, + {Py_tp_repr, (void *)__pyx_memoryview___repr__}, + {Py_sq_length, (void *)__pyx_memoryview___len__}, + {Py_sq_item, (void *)__pyx_sq_item_memoryview}, + {Py_mp_length, (void *)__pyx_memoryview___len__}, + {Py_mp_subscript, (void *)__pyx_memoryview___getitem__}, + {Py_mp_ass_subscript, (void *)__pyx_mp_ass_subscript_memoryview}, + {Py_tp_str, (void *)__pyx_memoryview___str__}, + #if defined(Py_bf_getbuffer) + {Py_bf_getbuffer, (void *)__pyx_memoryview_getbuffer}, + #endif + {Py_tp_traverse, (void *)__pyx_tp_traverse_memoryview}, + {Py_tp_clear, (void *)__pyx_tp_clear_memoryview}, + {Py_tp_methods, (void *)__pyx_methods_memoryview}, + {Py_tp_getset, (void *)__pyx_getsets_memoryview}, + {Py_tp_new, (void *)__pyx_tp_new_memoryview}, + {0, 0}, +}; +static PyType_Spec __pyx_type___pyx_memoryview_spec = { + "blokus_gym.core.blokus_cython.memoryview", + sizeof(struct __pyx_memoryview_obj), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type___pyx_memoryview_slots, +}; +#else + +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 = { + __pyx_memoryview_getbuffer, /*bf_getbuffer*/ + 0, /*bf_releasebuffer*/ +}; + +static PyTypeObject __pyx_type___pyx_memoryview = { + PyVarObject_HEAD_INIT(0, 0) + "blokus_gym.core.blokus_cython.""memoryview", /*tp_name*/ + sizeof(struct __pyx_memoryview_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_memoryview, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + __pyx_memoryview___repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_memoryview, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_memoryview, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + __pyx_memoryview___str__, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + &__pyx_tp_as_buffer_memoryview, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_memoryview, /*tp_traverse*/ + __pyx_tp_clear_memoryview, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_memoryview, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_memoryview, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_memoryview, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct__memoryviewslice __pyx_vtable__memoryviewslice; + +static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_memoryviewslice_obj *p; + PyObject *o = __pyx_tp_new_memoryview(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_memoryviewslice_obj *)o); + p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_memoryview*)__pyx_vtabptr__memoryviewslice; + p->from_object = Py_None; Py_INCREF(Py_None); + p->from_slice.memview = NULL; + return o; +} + +static void __pyx_tp_dealloc__memoryviewslice(PyObject *o) { + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc__memoryviewslice) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_DeallocKeepAliveBegin(o); + __pyx_memoryviewslice___dealloc__(o); + __Pyx_DeallocKeepAliveEnd(o); + 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_XCLEAR_MEMVIEW(&p->from_slice, 1); + return 0; +} + +static PyMethodDef __pyx_methods__memoryviewslice[] = { + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryviewslice_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryviewslice_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type___pyx_memoryviewslice_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc__memoryviewslice}, + {Py_tp_doc, (void *)PyDoc_STR("Internal class for passing memoryview slices to Python")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse__memoryviewslice}, + {Py_tp_clear, (void *)__pyx_tp_clear__memoryviewslice}, + {Py_tp_methods, (void *)__pyx_methods__memoryviewslice}, + {Py_tp_new, (void *)__pyx_tp_new__memoryviewslice}, + {0, 0}, +}; +static PyType_Spec __pyx_type___pyx_memoryviewslice_spec = { + "blokus_gym.core.blokus_cython._memoryviewslice", + sizeof(struct __pyx_memoryviewslice_obj), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_SEQUENCE, + __pyx_type___pyx_memoryviewslice_slots, +}; +#else + +static PyTypeObject __pyx_type___pyx_memoryviewslice = { + PyVarObject_HEAD_INIT(0, 0) + "blokus_gym.core.blokus_cython.""_memoryviewslice", /*tp_name*/ + sizeof(struct __pyx_memoryviewslice_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc__memoryviewslice, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + #if CYTHON_COMPILING_IN_PYPY || 0 + __pyx_memoryview___repr__, /*tp_repr*/ + #else + 0, /*tp_repr*/ + #endif + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + #if CYTHON_COMPILING_IN_PYPY || 0 + __pyx_memoryview___str__, /*tp_str*/ + #else + 0, /*tp_str*/ + #endif + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_SEQUENCE, /*tp_flags*/ + PyDoc_STR("Internal class for passing memoryview slices to Python"), /*tp_doc*/ + __pyx_tp_traverse__memoryviewslice, /*tp_traverse*/ + __pyx_tp_clear__memoryviewslice, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods__memoryviewslice, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new__memoryviewslice, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; +/* #### Code section: initfunc_declarations ### */ +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate); /*proto*/ +/* #### Code section: init_module ### */ + +static int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __pyx_v_10blokus_gym_4core_13blokus_cython__I1_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__I2_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__I3_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__V3_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__I4_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__L4_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__T4_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__S4_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__O4_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__I5_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__L5_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__Y5_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__N5_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__T5_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__U5_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__V5_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__W5_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__Z5_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__F5_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__X5_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__P5_squares = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__I1 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__I2 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__I3 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__V3 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__I4 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__L4 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__T4 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__S4 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__O4 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__I5 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__L5 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__Y5 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__N5 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__T5 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__U5 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__V5 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__W5 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__Z5 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__F5 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__X5 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython__P5 = ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)Py_None); Py_INCREF(Py_None); + __pyx_v_10blokus_gym_4core_13blokus_cython_STANDARD_PIECES = ((PyObject*)Py_None); Py_INCREF(Py_None); + __pyx_collections_abc_Sequence = Py_None; Py_INCREF(Py_None); + generic = Py_None; Py_INCREF(Py_None); + strided = Py_None; Py_INCREF(Py_None); + indirect = Py_None; Py_INCREF(Py_None); + contiguous = Py_None; Py_INCREF(Py_None); + indirect_contiguous = Py_None; Py_INCREF(Py_None); + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + __pyx_vtabptr_10blokus_gym_4core_13blokus_cython_Board = &__pyx_vtable_10blokus_gym_4core_13blokus_cython_Board; + __pyx_vtable_10blokus_gym_4core_13blokus_cython_Board.is_cell_empty = (int (*)(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Board *, int, int))__pyx_f_10blokus_gym_4core_13blokus_cython_5Board_is_cell_empty; + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_10blokus_gym_4core_13blokus_cython_Board_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board)) __PYX_ERR(0, 17, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_10blokus_gym_4core_13blokus_cython_Board_spec, __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board) < (0)) __PYX_ERR(0, 17, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board = &__pyx_type_10blokus_gym_4core_13blokus_cython_Board; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board) < (0)) __PYX_ERR(0, 17, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board->tp_dictoffset && __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board, __pyx_vtabptr_10blokus_gym_4core_13blokus_cython_Board) < (0)) __PYX_ERR(0, 17, __pyx_L1_error) + if (__Pyx_MergeVtables(__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board) < (0)) __PYX_ERR(0, 17, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_Board, (PyObject *) __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board) < (0)) __PYX_ERR(0, 17, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board) < (0)) __PYX_ERR(0, 17, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_10blokus_gym_4core_13blokus_cython_Move_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move)) __PYX_ERR(0, 171, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_10blokus_gym_4core_13blokus_cython_Move_spec, __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move) < (0)) __PYX_ERR(0, 171, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move = &__pyx_type_10blokus_gym_4core_13blokus_cython_Move; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move) < (0)) __PYX_ERR(0, 171, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move->tp_dictoffset && __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_Move, (PyObject *) __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move) < (0)) __PYX_ERR(0, 171, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move) < (0)) __PYX_ERR(0, 171, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_10blokus_gym_4core_13blokus_cython_PieceOrientation_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation)) __PYX_ERR(0, 189, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_10blokus_gym_4core_13blokus_cython_PieceOrientation_spec, __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation) < (0)) __PYX_ERR(0, 189, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation = &__pyx_type_10blokus_gym_4core_13blokus_cython_PieceOrientation; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation) < (0)) __PYX_ERR(0, 189, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation->tp_dictoffset && __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_PieceOrientation, (PyObject *) __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation) < (0)) __PYX_ERR(0, 189, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation) < (0)) __PYX_ERR(0, 189, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_10blokus_gym_4core_13blokus_cython_Piece_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece)) __PYX_ERR(0, 204, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_10blokus_gym_4core_13blokus_cython_Piece_spec, __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece) < (0)) __PYX_ERR(0, 204, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece = &__pyx_type_10blokus_gym_4core_13blokus_cython_Piece; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece) < (0)) __PYX_ERR(0, 204, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece->tp_dictoffset && __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_Piece, (PyObject *) __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece) < (0)) __PYX_ERR(0, 204, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece) < (0)) __PYX_ERR(0, 204, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_10blokus_gym_4core_13blokus_cython_PieceSet_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet)) __PYX_ERR(0, 219, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_10blokus_gym_4core_13blokus_cython_PieceSet_spec, __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet) < (0)) __PYX_ERR(0, 219, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet = &__pyx_type_10blokus_gym_4core_13blokus_cython_PieceSet; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet) < (0)) __PYX_ERR(0, 219, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet->tp_dictoffset && __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_PieceSet, (PyObject *) __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet) < (0)) __PYX_ERR(0, 219, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet) < (0)) __PYX_ERR(0, 219, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_10blokus_gym_4core_13blokus_cython_PlayerState_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState)) __PYX_ERR(0, 373, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_10blokus_gym_4core_13blokus_cython_PlayerState_spec, __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState) < (0)) __PYX_ERR(0, 373, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState = &__pyx_type_10blokus_gym_4core_13blokus_cython_PlayerState; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState) < (0)) __PYX_ERR(0, 373, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState->tp_dictoffset && __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_PlayerState, (PyObject *) __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState) < (0)) __PYX_ERR(0, 373, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState) < (0)) __PYX_ERR(0, 373, __pyx_L1_error) + __pyx_vtabptr_10blokus_gym_4core_13blokus_cython_BlokusGame = &__pyx_vtable_10blokus_gym_4core_13blokus_cython_BlokusGame; + __pyx_vtable_10blokus_gym_4core_13blokus_cython_BlokusGame._generate_action_space = (void (*)(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *))__pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame__generate_action_space; + __pyx_vtable_10blokus_gym_4core_13blokus_cython_BlokusGame._get_placed_squares = (PyObject *(*)(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *, struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *))__pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame__get_placed_squares; + __pyx_vtable_10blokus_gym_4core_13blokus_cython_BlokusGame._get_placed_corners = (PyObject *(*)(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *, struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *))__pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame__get_placed_corners; + __pyx_vtable_10blokus_gym_4core_13blokus_cython_BlokusGame.valid_move = (int (*)(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *, int, struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Move *, int __pyx_skip_dispatch))__pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame_valid_move; + __pyx_vtable_10blokus_gym_4core_13blokus_cython_BlokusGame.get_valid_actions = (PyObject *(*)(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *, int, int __pyx_skip_dispatch))__pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame_get_valid_actions; + __pyx_vtable_10blokus_gym_4core_13blokus_cython_BlokusGame.has_valid_moves = (int (*)(struct __pyx_obj_10blokus_gym_4core_13blokus_cython_BlokusGame *, int, int __pyx_skip_dispatch))__pyx_f_10blokus_gym_4core_13blokus_cython_10BlokusGame_has_valid_moves; + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_10blokus_gym_4core_13blokus_cython_BlokusGame_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame)) __PYX_ERR(0, 396, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_10blokus_gym_4core_13blokus_cython_BlokusGame_spec, __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame) < (0)) __PYX_ERR(0, 396, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame = &__pyx_type_10blokus_gym_4core_13blokus_cython_BlokusGame; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame) < (0)) __PYX_ERR(0, 396, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame->tp_dictoffset && __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame, __pyx_vtabptr_10blokus_gym_4core_13blokus_cython_BlokusGame) < (0)) __PYX_ERR(0, 396, __pyx_L1_error) + if (__Pyx_MergeVtables(__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame) < (0)) __PYX_ERR(0, 396, __pyx_L1_error) + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_BlokusGame, (PyObject *) __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame) < (0)) __PYX_ERR(0, 396, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame) < (0)) __PYX_ERR(0, 396, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr)) __PYX_ERR(0, 241, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr_spec, __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr) < (0)) __PYX_ERR(0, 241, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr = &__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr) < (0)) __PYX_ERR(0, 241, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr->tp_dictoffset && __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct__genexpr->tp_getattro = PyObject_GenericGetAttr; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr)) __PYX_ERR(0, 351, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr_spec, __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr) < (0)) __PYX_ERR(0, 351, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr = &__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr) < (0)) __PYX_ERR(0, 351, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr->tp_dictoffset && __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_1_genexpr->tp_getattro = PyObject_GenericGetAttr; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr)) __PYX_ERR(0, 352, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr_spec, __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr) < (0)) __PYX_ERR(0, 352, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr = &__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr) < (0)) __PYX_ERR(0, 352, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr->tp_dictoffset && __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_2_genexpr->tp_getattro = PyObject_GenericGetAttr; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr)) __PYX_ERR(0, 481, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr_spec, __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr) < (0)) __PYX_ERR(0, 481, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr = &__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr) < (0)) __PYX_ERR(0, 481, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr->tp_dictoffset && __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_3_genexpr->tp_getattro = PyObject_GenericGetAttr; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr)) __PYX_ERR(0, 482, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr_spec, __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr) < (0)) __PYX_ERR(0, 482, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr = &__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr) < (0)) __PYX_ERR(0, 482, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr->tp_dictoffset && __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_4_genexpr->tp_getattro = PyObject_GenericGetAttr; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr)) __PYX_ERR(0, 754, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr_spec, __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr) < (0)) __PYX_ERR(0, 754, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr = &__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr) < (0)) __PYX_ERR(0, 754, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr->tp_dictoffset && __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_5_genexpr->tp_getattro = PyObject_GenericGetAttr; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr)) __PYX_ERR(0, 756, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr_spec, __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr) < (0)) __PYX_ERR(0, 756, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr = &__pyx_type_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr) < (0)) __PYX_ERR(0, 756, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr->tp_dictoffset && __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_10blokus_gym_4core_13blokus_cython___pyx_scope_struct_6_genexpr->tp_getattro = PyObject_GenericGetAttr; + } + #endif + __pyx_vtabptr_array = &__pyx_vtable_array; + __pyx_vtable_array.get_memview = (PyObject *(*)(struct __pyx_array_obj *))__pyx_array_get_memview; + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_array_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_array_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_array_type)) __PYX_ERR(1, 118, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_mstate->__pyx_array_type->tp_as_buffer = &__pyx_tp_as_buffer_array; + if (!__pyx_mstate->__pyx_array_type->tp_as_buffer->bf_releasebuffer && __pyx_mstate->__pyx_array_type->tp_base->tp_as_buffer && __pyx_mstate->__pyx_array_type->tp_base->tp_as_buffer->bf_releasebuffer) { + __pyx_mstate->__pyx_array_type->tp_as_buffer->bf_releasebuffer = __pyx_mstate->__pyx_array_type->tp_base->tp_as_buffer->bf_releasebuffer; + } + #elif defined(Py_bf_getbuffer) && defined(Py_bf_releasebuffer) + /* PY_VERSION_HEX >= 0x03090000 || Py_LIMITED_API >= 0x030B0000 */ + #elif defined(_MSC_VER) + #pragma message ("The buffer protocol is not supported in the Limited C-API < 3.11.") + #else + #warning "The buffer protocol is not supported in the Limited C-API < 3.11." + #endif + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_array_spec, __pyx_mstate->__pyx_array_type) < (0)) __PYX_ERR(1, 118, __pyx_L1_error) + #else + __pyx_mstate->__pyx_array_type = &__pyx_type___pyx_array; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_array_type) < (0)) __PYX_ERR(1, 118, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_array_type); + #endif + if (__Pyx_SetVtable(__pyx_mstate->__pyx_array_type, __pyx_vtabptr_array) < (0)) __PYX_ERR(1, 118, __pyx_L1_error) + if (__Pyx_MergeVtables(__pyx_mstate->__pyx_array_type) < (0)) __PYX_ERR(1, 118, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_array_type) < (0)) __PYX_ERR(1, 118, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_MemviewEnum_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_MemviewEnum_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_MemviewEnum_type)) __PYX_ERR(1, 307, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_MemviewEnum_spec, __pyx_mstate->__pyx_MemviewEnum_type) < (0)) __PYX_ERR(1, 307, __pyx_L1_error) + #else + __pyx_mstate->__pyx_MemviewEnum_type = &__pyx_type___pyx_MemviewEnum; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_MemviewEnum_type) < (0)) __PYX_ERR(1, 307, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_MemviewEnum_type); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_MemviewEnum_type->tp_dictoffset && __pyx_mstate->__pyx_MemviewEnum_type->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_MemviewEnum_type->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_MemviewEnum_type) < (0)) __PYX_ERR(1, 307, __pyx_L1_error) + __pyx_vtabptr_memoryview = &__pyx_vtable_memoryview; + __pyx_vtable_memoryview.get_item_pointer = (char *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_get_item_pointer; + __pyx_vtable_memoryview.is_slice = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_is_slice; + __pyx_vtable_memoryview.setitem_slice_assignment = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_slice_assignment; + __pyx_vtable_memoryview.setitem_slice_assign_scalar = (PyObject *(*)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_setitem_slice_assign_scalar; + __pyx_vtable_memoryview.setitem_indexed = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_indexed; + __pyx_vtable_memoryview.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryview_convert_item_to_object; + __pyx_vtable_memoryview.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryview_assign_item_from_object; + __pyx_vtable_memoryview._get_base = (PyObject *(*)(struct __pyx_memoryview_obj *))__pyx_memoryview__get_base; + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_memoryview_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_memoryview_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_memoryview_type)) __PYX_ERR(1, 342, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_mstate->__pyx_memoryview_type->tp_as_buffer = &__pyx_tp_as_buffer_memoryview; + if (!__pyx_mstate->__pyx_memoryview_type->tp_as_buffer->bf_releasebuffer && __pyx_mstate->__pyx_memoryview_type->tp_base->tp_as_buffer && __pyx_mstate->__pyx_memoryview_type->tp_base->tp_as_buffer->bf_releasebuffer) { + __pyx_mstate->__pyx_memoryview_type->tp_as_buffer->bf_releasebuffer = __pyx_mstate->__pyx_memoryview_type->tp_base->tp_as_buffer->bf_releasebuffer; + } + #elif defined(Py_bf_getbuffer) && defined(Py_bf_releasebuffer) + /* PY_VERSION_HEX >= 0x03090000 || Py_LIMITED_API >= 0x030B0000 */ + #elif defined(_MSC_VER) + #pragma message ("The buffer protocol is not supported in the Limited C-API < 3.11.") + #else + #warning "The buffer protocol is not supported in the Limited C-API < 3.11." + #endif + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_memoryview_spec, __pyx_mstate->__pyx_memoryview_type) < (0)) __PYX_ERR(1, 342, __pyx_L1_error) + #else + __pyx_mstate->__pyx_memoryview_type = &__pyx_type___pyx_memoryview; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_memoryview_type) < (0)) __PYX_ERR(1, 342, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_memoryview_type); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_memoryview_type->tp_dictoffset && __pyx_mstate->__pyx_memoryview_type->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_memoryview_type->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_mstate->__pyx_memoryview_type, __pyx_vtabptr_memoryview) < (0)) __PYX_ERR(1, 342, __pyx_L1_error) + if (__Pyx_MergeVtables(__pyx_mstate->__pyx_memoryview_type) < (0)) __PYX_ERR(1, 342, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_memoryview_type) < (0)) __PYX_ERR(1, 342, __pyx_L1_error) + __pyx_vtabptr__memoryviewslice = &__pyx_vtable__memoryviewslice; + __pyx_vtable__memoryviewslice.__pyx_base = *__pyx_vtabptr_memoryview; + __pyx_vtable__memoryviewslice.__pyx_base.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryviewslice_convert_item_to_object; + __pyx_vtable__memoryviewslice.__pyx_base.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryviewslice_assign_item_from_object; + __pyx_vtable__memoryviewslice.__pyx_base._get_base = (PyObject *(*)(struct __pyx_memoryview_obj *))__pyx_memoryviewslice__get_base; + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_memoryview_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 856, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_mstate->__pyx_memoryviewslice_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_memoryviewslice_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_mstate->__pyx_memoryviewslice_type)) __PYX_ERR(1, 856, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_memoryviewslice_spec, __pyx_mstate->__pyx_memoryviewslice_type) < (0)) __PYX_ERR(1, 856, __pyx_L1_error) + #else + __pyx_mstate->__pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_mstate_global->__pyx_memoryviewslice_type->tp_base = __pyx_mstate_global->__pyx_memoryview_type; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_memoryviewslice_type) < (0)) __PYX_ERR(1, 856, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_memoryviewslice_type); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_memoryviewslice_type->tp_dictoffset && __pyx_mstate->__pyx_memoryviewslice_type->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_memoryviewslice_type->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_mstate->__pyx_memoryviewslice_type, __pyx_vtabptr__memoryviewslice) < (0)) __PYX_ERR(1, 856, __pyx_L1_error) + if (__Pyx_MergeVtables(__pyx_mstate->__pyx_memoryviewslice_type) < (0)) __PYX_ERR(1, 856, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_memoryviewslice_type) < (0)) __PYX_ERR(1, 856, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_mstate->__pyx_ptype_7cpython_4type_type = __Pyx_ImportType_3_2_9(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyTypeObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + 0, 0, + #else + sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyHeapTypeObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_9); if (!__pyx_mstate->__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_mstate->__pyx_ptype_5numpy_dtype = __Pyx_ImportType_3_2_9(__pyx_t_1, "numpy", "dtype", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyArray_Descr), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyArray_Descr), + #else + sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyArray_Descr), + #endif + __Pyx_ImportType_CheckSize_Ignore_3_2_9); if (!__pyx_mstate->__pyx_ptype_5numpy_dtype) __PYX_ERR(2, 228, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_flatiter = __Pyx_ImportType_3_2_9(__pyx_t_1, "numpy", "flatiter", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyArrayIterObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyArrayIterObject), + #else + sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyArrayIterObject), + #endif + __Pyx_ImportType_CheckSize_Ignore_3_2_9); if (!__pyx_mstate->__pyx_ptype_5numpy_flatiter) __PYX_ERR(2, 273, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_broadcast = __Pyx_ImportType_3_2_9(__pyx_t_1, "numpy", "broadcast", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyArrayMultiIterObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyArrayMultiIterObject), + #else + sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyArrayMultiIterObject), + #endif + __Pyx_ImportType_CheckSize_Ignore_3_2_9); if (!__pyx_mstate->__pyx_ptype_5numpy_broadcast) __PYX_ERR(2, 277, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_ndarray = __Pyx_ImportType_3_2_9(__pyx_t_1, "numpy", "ndarray", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyArrayObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyArrayObject), + #else + sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyArrayObject), + #endif + __Pyx_ImportType_CheckSize_Ignore_3_2_9); if (!__pyx_mstate->__pyx_ptype_5numpy_ndarray) __PYX_ERR(2, 316, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_generic = __Pyx_ImportType_3_2_9(__pyx_t_1, "numpy", "generic", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_9); if (!__pyx_mstate->__pyx_ptype_5numpy_generic) __PYX_ERR(2, 825, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_number = __Pyx_ImportType_3_2_9(__pyx_t_1, "numpy", "number", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_9); if (!__pyx_mstate->__pyx_ptype_5numpy_number) __PYX_ERR(2, 827, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_integer = __Pyx_ImportType_3_2_9(__pyx_t_1, "numpy", "integer", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_9); if (!__pyx_mstate->__pyx_ptype_5numpy_integer) __PYX_ERR(2, 829, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_signedinteger = __Pyx_ImportType_3_2_9(__pyx_t_1, "numpy", "signedinteger", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_9); if (!__pyx_mstate->__pyx_ptype_5numpy_signedinteger) __PYX_ERR(2, 831, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType_3_2_9(__pyx_t_1, "numpy", "unsignedinteger", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_9); if (!__pyx_mstate->__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(2, 833, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_inexact = __Pyx_ImportType_3_2_9(__pyx_t_1, "numpy", "inexact", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_9); if (!__pyx_mstate->__pyx_ptype_5numpy_inexact) __PYX_ERR(2, 835, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_floating = __Pyx_ImportType_3_2_9(__pyx_t_1, "numpy", "floating", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_9); if (!__pyx_mstate->__pyx_ptype_5numpy_floating) __PYX_ERR(2, 837, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_complexfloating = __Pyx_ImportType_3_2_9(__pyx_t_1, "numpy", "complexfloating", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_9); if (!__pyx_mstate->__pyx_ptype_5numpy_complexfloating) __PYX_ERR(2, 839, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_flexible = __Pyx_ImportType_3_2_9(__pyx_t_1, "numpy", "flexible", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_9); if (!__pyx_mstate->__pyx_ptype_5numpy_flexible) __PYX_ERR(2, 841, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_character = __Pyx_ImportType_3_2_9(__pyx_t_1, "numpy", "character", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_9); if (!__pyx_mstate->__pyx_ptype_5numpy_character) __PYX_ERR(2, 843, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_ufunc = __Pyx_ImportType_3_2_9(__pyx_t_1, "numpy", "ufunc", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyUFuncObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyUFuncObject), + #else + sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_9(PyUFuncObject), + #endif + __Pyx_ImportType_CheckSize_Ignore_3_2_9); if (!__pyx_mstate->__pyx_ptype_5numpy_ufunc) __PYX_ERR(2, 907, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_blokus_cython(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_blokus_cython}, + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + {Py_mod_gil, __Pyx_FREETHREADING_COMPATIBLE}, + #endif + #if PY_VERSION_HEX >= 0x030C0000 && CYTHON_USE_MODULE_STATE + {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED}, + #endif + {0, NULL} +}; +#endif + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "blokus_cython", + 0, /* m_doc */ + #if CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstatetype), /* m_size */ + #else + (CYTHON_PEP489_MULTI_PHASE_INIT) ? 0 : -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ + #else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ + #endif + }; + #ifdef __cplusplus +} /* anonymous namespace */ +#endif + +/* PyModInitFuncType */ +#ifndef CYTHON_NO_PYINIT_EXPORT + #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#else + #ifdef __cplusplus + #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * + #else + #define __Pyx_PyMODINIT_FUNC PyObject * + #endif +#endif + +__Pyx_PyMODINIT_FUNC PyInit_blokus_cython(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_blokus_cython(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +/* ModuleCreationPEP489 */ +#if CYTHON_COMPILING_IN_LIMITED_API && (__PYX_LIMITED_VERSION_HEX < 0x03090000\ + || ((defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)) && __PYX_LIMITED_VERSION_HEX < 0x030A0000)) +static PY_INT64_T __Pyx_GetCurrentInterpreterId(void) { + { + PyObject *module = PyImport_ImportModule("_interpreters"); // 3.13+ I think + if (!module) { + PyErr_Clear(); // just try the 3.8-3.12 version + module = PyImport_ImportModule("_xxsubinterpreters"); + if (!module) goto bad; + } + PyObject *current = PyObject_CallMethod(module, "get_current", NULL); + Py_DECREF(module); + if (!current) goto bad; + if (PyTuple_Check(current)) { + PyObject *new_current = PySequence_GetItem(current, 0); + Py_DECREF(current); + current = new_current; + if (!new_current) goto bad; + } + long long as_c_int = PyLong_AsLongLong(current); + Py_DECREF(current); + return as_c_int; + } + bad: + PySys_WriteStderr("__Pyx_GetCurrentInterpreterId failed. Try setting the C define CYTHON_PEP489_MULTI_PHASE_INIT=0\n"); + return -1; +} +#endif +#if !CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + static PY_INT64_T main_interpreter_id = -1; +#if CYTHON_COMPILING_IN_GRAAL && defined(GRAALPY_VERSION_NUM) && GRAALPY_VERSION_NUM > 0x19000000 + PY_INT64_T current_id = GraalPyInterpreterState_GetIDFromThreadState(PyThreadState_Get()); +#elif CYTHON_COMPILING_IN_GRAAL + PY_INT64_T current_id = PyInterpreterState_GetIDFromThreadState(PyThreadState_Get()); +#elif CYTHON_COMPILING_IN_LIMITED_API && (__PYX_LIMITED_VERSION_HEX < 0x03090000\ + || ((defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)) && __PYX_LIMITED_VERSION_HEX < 0x030A0000)) + PY_INT64_T current_id = __Pyx_GetCurrentInterpreterId(); +#elif CYTHON_COMPILING_IN_LIMITED_API + PY_INT64_T current_id = PyInterpreterState_GetID(PyInterpreterState_Get()); +#else + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); +#endif + if (unlikely(current_id == -1)) { + return -1; + } + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return 0; + } else if (unlikely(main_interpreter_id != current_id)) { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +#endif +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, PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); + #if !CYTHON_USE_MODULE_STATE + if (__Pyx_check_single_interpreter()) + return NULL; + #endif + 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_blokus_cython(PyObject *__pyx_pyinit_module) +#endif +{ + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif + __pyx_mstatetype *__pyx_mstate = NULL; + 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; + size_t __pyx_t_6; + static PyThread_type_lock __pyx_t_7[8]; + int __pyx_t_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 'blokus_cython' has already been imported. Re-initialisation is not supported."); + return -1; + } + #else + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_t_1 = __pyx_pyinit_module; + Py_INCREF(__pyx_t_1); + #else + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #if CYTHON_USE_MODULE_STATE + { + int add_module_result = __Pyx_State_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "blokus_cython" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = __pyx_t_1; + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + PyUnstable_Module_SetGIL(__pyx_m, Py_MOD_GIL_USED); + #endif + __pyx_mstate = __pyx_mstate_global; + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_mstate->__pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_mstate->__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_mstate->__pyx_d); + __pyx_mstate->__pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_mstate->__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_cython_runtime = __Pyx_PyImport_AddModuleRef("cython_runtime"); if (unlikely(!__pyx_mstate->__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_mstate->__pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /* ImportRefnannyAPI */ + #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("PyInit_blokus_cython", 0); + __Pyx_init_runtime_version(); + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_mstate->__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Library function declarations ---*/ + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + stringtab_initialized = 1; + if (__Pyx_InitGlobals() < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_module_is_main_blokus_gym__core__blokus_cython) { + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_name_2, __pyx_mstate_global->__pyx_n_u_main) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "blokus_gym.core.blokus_cython")) { + if (unlikely((PyDict_SetItemString(modules, "blokus_gym.core.blokus_cython", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_CreateCodeObjects(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(__pyx_mstate); + (void)__Pyx_modinit_variable_export_code(__pyx_mstate); + (void)__Pyx_modinit_function_export_code(__pyx_mstate); + if (unlikely((__Pyx_modinit_type_init_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_import_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_variable_import_code(__pyx_mstate); + (void)__Pyx_modinit_function_import_code(__pyx_mstate); + /*--- Execution code ---*/ + + /* "View.MemoryView":108 + * + * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" + * try: # <<<<<<<<<<<<<< + * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence + * except: +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "View.MemoryView":109 + * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" + * try: + * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence # <<<<<<<<<<<<<< + * except: + * +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_collections_abc}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin___import__, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 109, __pyx_L2_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_abc); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 109, __pyx_L2_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_Sequence); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 109, __pyx_L2_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XGOTREF(__pyx_collections_abc_Sequence); + __Pyx_DECREF_SET(__pyx_collections_abc_Sequence, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":108 + * + * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" + * try: # <<<<<<<<<<<<<< + * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence + * except: +*/ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L7_try_end; + __pyx_L2_error:; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "View.MemoryView":110 + * try: + * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence + * except: # <<<<<<<<<<<<<< + * + * __pyx_collections_abc_Sequence = None +*/ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + + /* "View.MemoryView":112 + * except: + * + * __pyx_collections_abc_Sequence = None # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_INCREF(Py_None); + __Pyx_XGOTREF(__pyx_collections_abc_Sequence); + __Pyx_DECREF_SET(__pyx_collections_abc_Sequence, Py_None); + __Pyx_GIVEREF(Py_None); + goto __pyx_L3_exception_handled; + } + __pyx_L3_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + __pyx_L7_try_end:; + } + + /* "View.MemoryView":247 + * + * + * try: # <<<<<<<<<<<<<< + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_1); + /*try:*/ { + + /* "View.MemoryView":248 + * + * try: + * count = __pyx_collections_abc_Sequence.count # <<<<<<<<<<<<<< + * index = __pyx_collections_abc_Sequence.index + * except: +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_mstate_global->__pyx_n_u_count); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 248, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_array_type, __pyx_mstate_global->__pyx_n_u_count, __pyx_t_4) < (0)) __PYX_ERR(1, 248, __pyx_L10_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":249 + * try: + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index # <<<<<<<<<<<<<< + * except: + * pass +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_mstate_global->__pyx_n_u_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 249, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_array_type, __pyx_mstate_global->__pyx_n_u_index, __pyx_t_4) < (0)) __PYX_ERR(1, 249, __pyx_L10_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":247 + * + * + * try: # <<<<<<<<<<<<<< + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index +*/ + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L15_try_end; + __pyx_L10_error:; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "View.MemoryView":250 + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index + * except: # <<<<<<<<<<<<<< + * pass + * +*/ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L11_exception_handled; + } + __pyx_L11_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_2, __pyx_t_1); + __pyx_L15_try_end:; + } + + /* "View.MemoryView":315 + * return self.name + * + * cdef generic = Enum("") # <<<<<<<<<<<<<< + * cdef strided = Enum("") # default + * cdef indirect = Enum("") +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_strided_and_direct_or_indirect}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_MemviewEnum_type, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 315, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF(generic); + __Pyx_DECREF_SET(generic, ((PyObject *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":316 + * + * cdef generic = Enum("") + * cdef strided = Enum("") # default # <<<<<<<<<<<<<< + * cdef indirect = Enum("") + * +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_strided_and_direct}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_MemviewEnum_type, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 316, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF(strided); + __Pyx_DECREF_SET(strided, ((PyObject *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":317 + * cdef generic = Enum("") + * cdef strided = Enum("") # default + * cdef indirect = Enum("") # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_strided_and_indirect}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_MemviewEnum_type, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 317, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF(indirect); + __Pyx_DECREF_SET(indirect, ((PyObject *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":320 + * + * + * cdef contiguous = Enum("") # <<<<<<<<<<<<<< + * cdef indirect_contiguous = Enum("") + * +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_contiguous_and_direct}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_MemviewEnum_type, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 320, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF(contiguous); + __Pyx_DECREF_SET(contiguous, ((PyObject *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":321 + * + * cdef contiguous = Enum("") + * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_contiguous_and_indirect}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_MemviewEnum_type, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 321, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF(indirect_contiguous); + __Pyx_DECREF_SET(indirect_contiguous, ((PyObject *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":329 + * + * + * cdef int __pyx_memoryview_thread_locks_used = 0 # <<<<<<<<<<<<<< + * cdef PyThread_type_lock[8] __pyx_memoryview_thread_locks = [ + * PyThread_allocate_lock(), +*/ + __pyx_memoryview_thread_locks_used = 0; + + /* "View.MemoryView":330 + * + * cdef int __pyx_memoryview_thread_locks_used = 0 + * cdef PyThread_type_lock[8] __pyx_memoryview_thread_locks = [ # <<<<<<<<<<<<<< + * PyThread_allocate_lock(), + * PyThread_allocate_lock(), +*/ + __pyx_t_7[0] = PyThread_allocate_lock(); + __pyx_t_7[1] = PyThread_allocate_lock(); + __pyx_t_7[2] = PyThread_allocate_lock(); + __pyx_t_7[3] = PyThread_allocate_lock(); + __pyx_t_7[4] = PyThread_allocate_lock(); + __pyx_t_7[5] = PyThread_allocate_lock(); + __pyx_t_7[6] = PyThread_allocate_lock(); + __pyx_t_7[7] = PyThread_allocate_lock(); + memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_7, sizeof(__pyx_memoryview_thread_locks[0]) * (8)); + + /* "View.MemoryView":888 + * + * + * try: # <<<<<<<<<<<<<< + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "View.MemoryView":889 + * + * try: + * count = __pyx_collections_abc_Sequence.count # <<<<<<<<<<<<<< + * index = __pyx_collections_abc_Sequence.index + * except: +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_mstate_global->__pyx_n_u_count); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 889, __pyx_L18_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_memoryviewslice_type, __pyx_mstate_global->__pyx_n_u_count, __pyx_t_4) < (0)) __PYX_ERR(1, 889, __pyx_L18_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":890 + * try: + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index # <<<<<<<<<<<<<< + * except: + * pass +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_mstate_global->__pyx_n_u_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 890, __pyx_L18_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_memoryviewslice_type, __pyx_mstate_global->__pyx_n_u_index, __pyx_t_4) < (0)) __PYX_ERR(1, 890, __pyx_L18_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":888 + * + * + * try: # <<<<<<<<<<<<<< + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index +*/ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L23_try_end; + __pyx_L18_error:; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "View.MemoryView":891 + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index + * except: # <<<<<<<<<<<<<< + * pass + * +*/ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L19_exception_handled; + } + __pyx_L19_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + __pyx_L23_try_end:; + } + + /* "View.MemoryView":894 + * pass + * + * try: # <<<<<<<<<<<<<< + * if __pyx_collections_abc_Sequence: + * +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_1); + /*try:*/ { + + /* "View.MemoryView":895 + * + * try: + * if __pyx_collections_abc_Sequence: # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_collections_abc_Sequence); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(1, 895, __pyx_L26_error) + if (__pyx_t_8) { + + /* "View.MemoryView":899 + * + * + * __pyx_collections_abc_Sequence.register(_memoryviewslice) # <<<<<<<<<<<<<< + * __pyx_collections_abc_Sequence.register(array) + * except: +*/ + __pyx_t_5 = __pyx_collections_abc_Sequence; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, ((PyObject *)__pyx_mstate_global->__pyx_memoryviewslice_type)}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_register, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 899, __pyx_L26_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":900 + * + * __pyx_collections_abc_Sequence.register(_memoryviewslice) + * __pyx_collections_abc_Sequence.register(array) # <<<<<<<<<<<<<< + * except: + * pass # ignore failure, it's a minor issue +*/ + __pyx_t_5 = __pyx_collections_abc_Sequence; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, ((PyObject *)__pyx_mstate_global->__pyx_array_type)}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_register, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 900, __pyx_L26_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":895 + * + * try: + * if __pyx_collections_abc_Sequence: # <<<<<<<<<<<<<< + * + * +*/ + } + + /* "View.MemoryView":894 + * pass + * + * try: # <<<<<<<<<<<<<< + * if __pyx_collections_abc_Sequence: + * +*/ + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L31_try_end; + __pyx_L26_error:; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "View.MemoryView":901 + * __pyx_collections_abc_Sequence.register(_memoryviewslice) + * __pyx_collections_abc_Sequence.register(array) + * except: # <<<<<<<<<<<<<< + * pass # ignore failure, it's a minor issue + * +*/ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L27_exception_handled; + } + __pyx_L27_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_2, __pyx_t_1); + __pyx_L31_try_end:; + } + + /* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x82a3537, 0x6ae9995, 0xb068931, b'name') +*/ + __pyx_t_4 = PyCFunction_NewEx(&__pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum, NULL, __pyx_mstate_global->__pyx_n_u_View_MemoryView); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Enum, __pyx_t_4) < (0)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":9 + * cimport cython + * from cython cimport bint + * import numpy as np # <<<<<<<<<<<<<< + * cimport numpy as cnp + * +*/ + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_numpy, 0, 0, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 9, __pyx_L1_error) + __pyx_t_4 = __pyx_t_1; + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_np, __pyx_t_4) < (0)) __PYX_ERR(0, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":35 + * self._occupied_cache = {} + * + * def place(self, int player_idx, list squares): # <<<<<<<<<<<<<< + * """Place a player's piece on the board.""" + * cdef int x, y +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_3place, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Board_place, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[7])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board, __pyx_mstate_global->__pyx_n_u_place, __pyx_t_4) < (0)) __PYX_ERR(0, 35, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":49 + * self._occupied_cache[player_idx].update(squares) + * + * def clear(self) -> None: # <<<<<<<<<<<<<< + * """Reset the board to empty.""" + * self.grid.fill(0) +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < (0)) __PYX_ERR(0, 49, __pyx_L1_error) + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_5clear, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Board_clear, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[8])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board, __pyx_mstate_global->__pyx_n_u_clear, __pyx_t_5) < (0)) __PYX_ERR(0, 49, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":53 + * self.grid.fill(0) + * + * def is_empty(self, int x, int y) -> bool: # <<<<<<<<<<<<<< + * """Check if a cell is empty (C-level fast).""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < (0)) __PYX_ERR(0, 53, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_7is_empty, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Board_is_empty, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[9])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board, __pyx_mstate_global->__pyx_n_u_is_empty, __pyx_t_4) < (0)) __PYX_ERR(0, 53, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":62 + * return False + * + * def in_bounds(self, int x, int y) -> bool: # <<<<<<<<<<<<<< + * """Check if coordinates are within the board (C-level fast).""" + * cdef int size = self.size +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < (0)) __PYX_ERR(0, 62, __pyx_L1_error) + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_9in_bounds, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Board_in_bounds, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[10])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board, __pyx_mstate_global->__pyx_n_u_in_bounds, __pyx_t_5) < (0)) __PYX_ERR(0, 62, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":67 + * return 0 <= x < size and 0 <= y < size + * + * def has_overlap(self, list squares) -> bool: # <<<<<<<<<<<<<< + * """Check if any square is already occupied (C-level fast).""" + * cdef int x, y +*/ + __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 67, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < (0)) __PYX_ERR(0, 67, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_11has_overlap, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Board_has_overlap, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[11])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 67, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board, __pyx_mstate_global->__pyx_n_u_has_overlap, __pyx_t_4) < (0)) __PYX_ERR(0, 67, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":85 + * return 0 <= x < size and 0 <= y < size and grid_view[y, x] == 0 + * + * def get_cell(self, int x, int y) -> int: # <<<<<<<<<<<<<< + * """Get the player index at a cell (0 = empty).""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < (0)) __PYX_ERR(0, 85, __pyx_L1_error) + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_13get_cell, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Board_get_cell, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[12])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board, __pyx_mstate_global->__pyx_n_u_get_cell, __pyx_t_5) < (0)) __PYX_ERR(0, 85, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":94 + * return 0 + * + * def get_player_squares(self, int player_idx) -> list: # <<<<<<<<<<<<<< + * """Get all squares occupied by a player.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_list) < (0)) __PYX_ERR(0, 94, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_15get_player_squares, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Board_get_player_squares, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[13])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board, __pyx_mstate_global->__pyx_n_u_get_player_squares, __pyx_t_4) < (0)) __PYX_ERR(0, 94, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":107 + * return result + * + * def get_player_occupied(self, int player_idx) -> set: # <<<<<<<<<<<<<< + * """Get all squares occupied by a player as a set.""" + * if player_idx not in self._occupied_cache: +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_set) < (0)) __PYX_ERR(0, 107, __pyx_L1_error) + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_17get_player_occupied, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Board_get_player_occupied, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[14])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board, __pyx_mstate_global->__pyx_n_u_get_player_occupied, __pyx_t_5) < (0)) __PYX_ERR(0, 107, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":113 + * return self._occupied_cache[player_idx] + * + * def get_player_corners(self, int player_idx) -> set: # <<<<<<<<<<<<<< + * """Get all corner cells adjacent to a player's pieces.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_set) < (0)) __PYX_ERR(0, 113, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_19get_player_corners, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Board_get_player_corners, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[15])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board, __pyx_mstate_global->__pyx_n_u_get_player_corners, __pyx_t_4) < (0)) __PYX_ERR(0, 113, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":128 + * return corners + * + * def get_occupied(self) -> set: # <<<<<<<<<<<<<< + * """Get all occupied cells.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_set) < (0)) __PYX_ERR(0, 128, __pyx_L1_error) + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_21get_occupied, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Board_get_occupied, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[16])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board, __pyx_mstate_global->__pyx_n_u_get_occupied, __pyx_t_5) < (0)) __PYX_ERR(0, 128, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":141 + * return result + * + * def is_full(self) -> bool: # <<<<<<<<<<<<<< + * """Check if the board is completely full.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bool) < (0)) __PYX_ERR(0, 141, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_23is_full, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Board_is_full, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[17])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board, __pyx_mstate_global->__pyx_n_u_is_full, __pyx_t_4) < (0)) __PYX_ERR(0, 141, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":153 + * return True + * + * def coverage(self) -> float: # <<<<<<<<<<<<<< + * """Get the fraction of the board that is occupied.""" + * cdef cnp.int8_t[:, :] grid_view = self.grid +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_float) < (0)) __PYX_ERR(0, 153, __pyx_L1_error) + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_25coverage, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Board_coverage, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[18])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board, __pyx_mstate_global->__pyx_n_u_coverage, __pyx_t_5) < (0)) __PYX_ERR(0, 153, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_27__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Board___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[19])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_5) < (0)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Board, (type(self), 0x0510d2c, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Board__set_state(self, __pyx_state) +*/ + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_5Board_29__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Board___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[20])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Board, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_5) < (0)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_4Move_5__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Move___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[21])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_5) < (0)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Move, (type(self), 0x4546268, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Move__set_state(self, __pyx_state) +*/ + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_4Move_7__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Move___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[22])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Move, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_5) < (0)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_16PieceOrientation_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PieceOrientation___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[23])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_5) < (0)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PieceOrientation, (type(self), 0xf86ecb3, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PieceOrientation__set_state(self, __pyx_state) +*/ + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_16PieceOrientation_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PieceOrientation___setstate_cyth, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[24])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceOrientation, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_5) < (0)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_5Piece_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Piece___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[25])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_5) < (0)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Piece, (type(self), 0xb4de42d, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Piece__set_state(self, __pyx_state) +*/ + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_5Piece_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_Piece___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[26])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_5) < (0)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":247 + * return len(self.pieces) + * + * def get_orientations(self, int piece_id) -> list: # <<<<<<<<<<<<<< + * return self.orientations[piece_id] + * +*/ + __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 247, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_list) < (0)) __PYX_ERR(0, 247, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_8PieceSet_3get_orientations, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PieceSet_get_orientations, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[27])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 247, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet, __pyx_mstate_global->__pyx_n_u_get_orientations, __pyx_t_4) < (0)) __PYX_ERR(0, 247, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":250 + * return self.orientations[piece_id] + * + * def get_piece(self, int piece_id) -> Piece: # <<<<<<<<<<<<<< + * return self.pieces[piece_id] + * +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_Piece) < (0)) __PYX_ERR(0, 250, __pyx_L1_error) + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_8PieceSet_5get_piece, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PieceSet_get_piece, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[28])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet, __pyx_mstate_global->__pyx_n_u_get_piece, __pyx_t_5) < (0)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":253 + * return self.pieces[piece_id] + * + * def get_piece_id(self, str name) -> int: # <<<<<<<<<<<<<< + * return self.piece_id_map[name] + * +*/ + __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 253, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < (0)) __PYX_ERR(0, 253, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_8PieceSet_7get_piece_id, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PieceSet_get_piece_id, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[29])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 253, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet, __pyx_mstate_global->__pyx_n_u_get_piece_id, __pyx_t_4) < (0)) __PYX_ERR(0, 253, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_8PieceSet_9__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PieceSet___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[30])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < (0)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PieceSet, (type(self), 0x0a4ef5f, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PieceSet__set_state(self, __pyx_state) +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_8PieceSet_11__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PieceSet___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[31])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PieceSet, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < (0)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":261 + * # ------------------------------------------------------------------- + * + * cdef frozenset _I1_squares = frozenset([(0, 0)]) # <<<<<<<<<<<<<< + * cdef frozenset _I2_squares = frozenset([(0, 0), (0, 1)]) + * cdef frozenset _I3_squares = frozenset([(0, 0), (0, 1), (0, 2)]) +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[12]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__I1_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__I1_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":262 + * + * cdef frozenset _I1_squares = frozenset([(0, 0)]) + * cdef frozenset _I2_squares = frozenset([(0, 0), (0, 1)]) # <<<<<<<<<<<<<< + * cdef frozenset _I3_squares = frozenset([(0, 0), (0, 1), (0, 2)]) + * cdef frozenset _V3_squares = frozenset([(0, 0), (1, 0), (0, 1)]) +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[13]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 262, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__I2_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__I2_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":263 + * cdef frozenset _I1_squares = frozenset([(0, 0)]) + * cdef frozenset _I2_squares = frozenset([(0, 0), (0, 1)]) + * cdef frozenset _I3_squares = frozenset([(0, 0), (0, 1), (0, 2)]) # <<<<<<<<<<<<<< + * cdef frozenset _V3_squares = frozenset([(0, 0), (1, 0), (0, 1)]) + * cdef frozenset _I4_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3)]) +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[15]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__I3_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__I3_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":264 + * cdef frozenset _I2_squares = frozenset([(0, 0), (0, 1)]) + * cdef frozenset _I3_squares = frozenset([(0, 0), (0, 1), (0, 2)]) + * cdef frozenset _V3_squares = frozenset([(0, 0), (1, 0), (0, 1)]) # <<<<<<<<<<<<<< + * cdef frozenset _I4_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3)]) + * cdef frozenset _L4_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0)]) +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[16]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__V3_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__V3_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":265 + * cdef frozenset _I3_squares = frozenset([(0, 0), (0, 1), (0, 2)]) + * cdef frozenset _V3_squares = frozenset([(0, 0), (1, 0), (0, 1)]) + * cdef frozenset _I4_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3)]) # <<<<<<<<<<<<<< + * cdef frozenset _L4_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0)]) + * cdef frozenset _T4_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1)]) +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[18]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__I4_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__I4_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":266 + * cdef frozenset _V3_squares = frozenset([(0, 0), (1, 0), (0, 1)]) + * cdef frozenset _I4_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3)]) + * cdef frozenset _L4_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0)]) # <<<<<<<<<<<<<< + * cdef frozenset _T4_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1)]) + * cdef frozenset _S4_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1)]) +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[19]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__L4_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__L4_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":267 + * cdef frozenset _I4_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3)]) + * cdef frozenset _L4_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0)]) + * cdef frozenset _T4_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1)]) # <<<<<<<<<<<<<< + * cdef frozenset _S4_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1)]) + * cdef frozenset _O4_squares = frozenset([(0, 0), (1, 0), (0, 1), (1, 1)]) +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[21]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__T4_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__T4_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":268 + * cdef frozenset _L4_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0)]) + * cdef frozenset _T4_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1)]) + * cdef frozenset _S4_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1)]) # <<<<<<<<<<<<<< + * cdef frozenset _O4_squares = frozenset([(0, 0), (1, 0), (0, 1), (1, 1)]) + * cdef frozenset _I5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4)]) +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[23]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__S4_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__S4_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":269 + * cdef frozenset _T4_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1)]) + * cdef frozenset _S4_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1)]) + * cdef frozenset _O4_squares = frozenset([(0, 0), (1, 0), (0, 1), (1, 1)]) # <<<<<<<<<<<<<< + * cdef frozenset _I5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4)]) + * cdef frozenset _L5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 0)]) +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[24]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 269, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__O4_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__O4_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":270 + * cdef frozenset _S4_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1)]) + * cdef frozenset _O4_squares = frozenset([(0, 0), (1, 0), (0, 1), (1, 1)]) + * cdef frozenset _I5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4)]) # <<<<<<<<<<<<<< + * cdef frozenset _L5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 0)]) + * cdef frozenset _Y5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1)]) +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[26]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__I5_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__I5_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":271 + * cdef frozenset _O4_squares = frozenset([(0, 0), (1, 0), (0, 1), (1, 1)]) + * cdef frozenset _I5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4)]) + * cdef frozenset _L5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 0)]) # <<<<<<<<<<<<<< + * cdef frozenset _Y5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1)]) + * cdef frozenset _N5_squares = frozenset([(0, 0), (1, 0), (2, 0), (2, 1), (3, 1)]) +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[27]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__L5_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__L5_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":272 + * cdef frozenset _I5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4)]) + * cdef frozenset _L5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 0)]) + * cdef frozenset _Y5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1)]) # <<<<<<<<<<<<<< + * cdef frozenset _N5_squares = frozenset([(0, 0), (1, 0), (2, 0), (2, 1), (3, 1)]) + * cdef frozenset _T5_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1), (1, 2)]) +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[28]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__Y5_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__Y5_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":273 + * cdef frozenset _L5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 0)]) + * cdef frozenset _Y5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1)]) + * cdef frozenset _N5_squares = frozenset([(0, 0), (1, 0), (2, 0), (2, 1), (3, 1)]) # <<<<<<<<<<<<<< + * cdef frozenset _T5_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1), (1, 2)]) + * cdef frozenset _U5_squares = frozenset([(0, 0), (2, 0), (0, 1), (1, 1), (2, 1)]) +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[30]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__N5_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__N5_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":274 + * cdef frozenset _Y5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1)]) + * cdef frozenset _N5_squares = frozenset([(0, 0), (1, 0), (2, 0), (2, 1), (3, 1)]) + * cdef frozenset _T5_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1), (1, 2)]) # <<<<<<<<<<<<<< + * cdef frozenset _U5_squares = frozenset([(0, 0), (2, 0), (0, 1), (1, 1), (2, 1)]) + * cdef frozenset _V5_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0), (2, 0)]) +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[32]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__T5_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__T5_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":275 + * cdef frozenset _N5_squares = frozenset([(0, 0), (1, 0), (2, 0), (2, 1), (3, 1)]) + * cdef frozenset _T5_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1), (1, 2)]) + * cdef frozenset _U5_squares = frozenset([(0, 0), (2, 0), (0, 1), (1, 1), (2, 1)]) # <<<<<<<<<<<<<< + * cdef frozenset _V5_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0), (2, 0)]) + * cdef frozenset _W5_squares = frozenset([(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)]) +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[33]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__U5_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__U5_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":276 + * cdef frozenset _T5_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1), (1, 2)]) + * cdef frozenset _U5_squares = frozenset([(0, 0), (2, 0), (0, 1), (1, 1), (2, 1)]) + * cdef frozenset _V5_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0), (2, 0)]) # <<<<<<<<<<<<<< + * cdef frozenset _W5_squares = frozenset([(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)]) + * cdef frozenset _Z5_squares = frozenset([(0, 0), (1, 0), (1, 1), (1, 2), (2, 2)]) +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[34]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__V5_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__V5_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":277 + * cdef frozenset _U5_squares = frozenset([(0, 0), (2, 0), (0, 1), (1, 1), (2, 1)]) + * cdef frozenset _V5_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0), (2, 0)]) + * cdef frozenset _W5_squares = frozenset([(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)]) # <<<<<<<<<<<<<< + * cdef frozenset _Z5_squares = frozenset([(0, 0), (1, 0), (1, 1), (1, 2), (2, 2)]) + * cdef frozenset _F5_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1), (1, 2)]) +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[35]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__W5_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__W5_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":278 + * cdef frozenset _V5_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0), (2, 0)]) + * cdef frozenset _W5_squares = frozenset([(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)]) + * cdef frozenset _Z5_squares = frozenset([(0, 0), (1, 0), (1, 1), (1, 2), (2, 2)]) # <<<<<<<<<<<<<< + * cdef frozenset _F5_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1), (1, 2)]) + * cdef frozenset _X5_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1), (1, -1)]) +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[37]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__Z5_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__Z5_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":279 + * cdef frozenset _W5_squares = frozenset([(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)]) + * cdef frozenset _Z5_squares = frozenset([(0, 0), (1, 0), (1, 1), (1, 2), (2, 2)]) + * cdef frozenset _F5_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1), (1, 2)]) # <<<<<<<<<<<<<< + * cdef frozenset _X5_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1), (1, -1)]) + * cdef frozenset _P5_squares = frozenset([(0, 0), (1, 0), (0, 1), (1, 1), (0, 2)]) +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[38]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 279, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__F5_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__F5_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":280 + * cdef frozenset _Z5_squares = frozenset([(0, 0), (1, 0), (1, 1), (1, 2), (2, 2)]) + * cdef frozenset _F5_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1), (1, 2)]) + * cdef frozenset _X5_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1), (1, -1)]) # <<<<<<<<<<<<<< + * cdef frozenset _P5_squares = frozenset([(0, 0), (1, 0), (0, 1), (1, 1), (0, 2)]) + * +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[39]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 280, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__X5_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__X5_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":281 + * cdef frozenset _F5_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1), (1, 2)]) + * cdef frozenset _X5_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1), (1, -1)]) + * cdef frozenset _P5_squares = frozenset([(0, 0), (1, 0), (0, 1), (1, 1), (0, 2)]) # <<<<<<<<<<<<<< + * + * cdef Piece _I1 = Piece("I1", _I1_squares) +*/ + __pyx_t_4 = __Pyx_PyFrozenSet_New(__pyx_mstate_global->__pyx_tuple[40]); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython__P5_squares); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__P5_squares, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":283 + * cdef frozenset _P5_squares = frozenset([(0, 0), (1, 0), (0, 1), (1, 1), (0, 2)]) + * + * cdef Piece _I1 = Piece("I1", _I1_squares) # <<<<<<<<<<<<<< + * cdef Piece _I2 = Piece("I2", _I2_squares) + * cdef Piece _I3 = Piece("I3", _I3_squares) +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_I1, __pyx_v_10blokus_gym_4core_13blokus_cython__I1_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 283, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__I1); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__I1, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":284 + * + * cdef Piece _I1 = Piece("I1", _I1_squares) + * cdef Piece _I2 = Piece("I2", _I2_squares) # <<<<<<<<<<<<<< + * cdef Piece _I3 = Piece("I3", _I3_squares) + * cdef Piece _V3 = Piece("V3", _V3_squares) +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_I2, __pyx_v_10blokus_gym_4core_13blokus_cython__I2_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 284, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__I2); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__I2, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":285 + * cdef Piece _I1 = Piece("I1", _I1_squares) + * cdef Piece _I2 = Piece("I2", _I2_squares) + * cdef Piece _I3 = Piece("I3", _I3_squares) # <<<<<<<<<<<<<< + * cdef Piece _V3 = Piece("V3", _V3_squares) + * cdef Piece _I4 = Piece("I4", _I4_squares) +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_I3, __pyx_v_10blokus_gym_4core_13blokus_cython__I3_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 285, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__I3); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__I3, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":286 + * cdef Piece _I2 = Piece("I2", _I2_squares) + * cdef Piece _I3 = Piece("I3", _I3_squares) + * cdef Piece _V3 = Piece("V3", _V3_squares) # <<<<<<<<<<<<<< + * cdef Piece _I4 = Piece("I4", _I4_squares) + * cdef Piece _L4 = Piece("L4", _L4_squares) +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_V3, __pyx_v_10blokus_gym_4core_13blokus_cython__V3_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 286, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__V3); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__V3, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":287 + * cdef Piece _I3 = Piece("I3", _I3_squares) + * cdef Piece _V3 = Piece("V3", _V3_squares) + * cdef Piece _I4 = Piece("I4", _I4_squares) # <<<<<<<<<<<<<< + * cdef Piece _L4 = Piece("L4", _L4_squares) + * cdef Piece _T4 = Piece("T4", _T4_squares) +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_I4, __pyx_v_10blokus_gym_4core_13blokus_cython__I4_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 287, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__I4); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__I4, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":288 + * cdef Piece _V3 = Piece("V3", _V3_squares) + * cdef Piece _I4 = Piece("I4", _I4_squares) + * cdef Piece _L4 = Piece("L4", _L4_squares) # <<<<<<<<<<<<<< + * cdef Piece _T4 = Piece("T4", _T4_squares) + * cdef Piece _S4 = Piece("S4", _S4_squares) +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_L4, __pyx_v_10blokus_gym_4core_13blokus_cython__L4_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 288, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__L4); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__L4, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":289 + * cdef Piece _I4 = Piece("I4", _I4_squares) + * cdef Piece _L4 = Piece("L4", _L4_squares) + * cdef Piece _T4 = Piece("T4", _T4_squares) # <<<<<<<<<<<<<< + * cdef Piece _S4 = Piece("S4", _S4_squares) + * cdef Piece _O4 = Piece("O4", _O4_squares) +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_T4, __pyx_v_10blokus_gym_4core_13blokus_cython__T4_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 289, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__T4); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__T4, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":290 + * cdef Piece _L4 = Piece("L4", _L4_squares) + * cdef Piece _T4 = Piece("T4", _T4_squares) + * cdef Piece _S4 = Piece("S4", _S4_squares) # <<<<<<<<<<<<<< + * cdef Piece _O4 = Piece("O4", _O4_squares) + * cdef Piece _I5 = Piece("I5", _I5_squares) +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_S4, __pyx_v_10blokus_gym_4core_13blokus_cython__S4_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 290, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__S4); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__S4, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":291 + * cdef Piece _T4 = Piece("T4", _T4_squares) + * cdef Piece _S4 = Piece("S4", _S4_squares) + * cdef Piece _O4 = Piece("O4", _O4_squares) # <<<<<<<<<<<<<< + * cdef Piece _I5 = Piece("I5", _I5_squares) + * cdef Piece _L5 = Piece("L5", _L5_squares) +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_O4, __pyx_v_10blokus_gym_4core_13blokus_cython__O4_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 291, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__O4); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__O4, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":292 + * cdef Piece _S4 = Piece("S4", _S4_squares) + * cdef Piece _O4 = Piece("O4", _O4_squares) + * cdef Piece _I5 = Piece("I5", _I5_squares) # <<<<<<<<<<<<<< + * cdef Piece _L5 = Piece("L5", _L5_squares) + * cdef Piece _Y5 = Piece("Y5", _Y5_squares) +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_I5, __pyx_v_10blokus_gym_4core_13blokus_cython__I5_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 292, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__I5); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__I5, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":293 + * cdef Piece _O4 = Piece("O4", _O4_squares) + * cdef Piece _I5 = Piece("I5", _I5_squares) + * cdef Piece _L5 = Piece("L5", _L5_squares) # <<<<<<<<<<<<<< + * cdef Piece _Y5 = Piece("Y5", _Y5_squares) + * cdef Piece _N5 = Piece("N5", _N5_squares) +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_L5, __pyx_v_10blokus_gym_4core_13blokus_cython__L5_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 293, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__L5); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__L5, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":294 + * cdef Piece _I5 = Piece("I5", _I5_squares) + * cdef Piece _L5 = Piece("L5", _L5_squares) + * cdef Piece _Y5 = Piece("Y5", _Y5_squares) # <<<<<<<<<<<<<< + * cdef Piece _N5 = Piece("N5", _N5_squares) + * cdef Piece _T5 = Piece("T5", _T5_squares) +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_Y5, __pyx_v_10blokus_gym_4core_13blokus_cython__Y5_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 294, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__Y5); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__Y5, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":295 + * cdef Piece _L5 = Piece("L5", _L5_squares) + * cdef Piece _Y5 = Piece("Y5", _Y5_squares) + * cdef Piece _N5 = Piece("N5", _N5_squares) # <<<<<<<<<<<<<< + * cdef Piece _T5 = Piece("T5", _T5_squares) + * cdef Piece _U5 = Piece("U5", _U5_squares) +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_N5, __pyx_v_10blokus_gym_4core_13blokus_cython__N5_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 295, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__N5); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__N5, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":296 + * cdef Piece _Y5 = Piece("Y5", _Y5_squares) + * cdef Piece _N5 = Piece("N5", _N5_squares) + * cdef Piece _T5 = Piece("T5", _T5_squares) # <<<<<<<<<<<<<< + * cdef Piece _U5 = Piece("U5", _U5_squares) + * cdef Piece _V5 = Piece("V5", _V5_squares) +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_T5, __pyx_v_10blokus_gym_4core_13blokus_cython__T5_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 296, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__T5); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__T5, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":297 + * cdef Piece _N5 = Piece("N5", _N5_squares) + * cdef Piece _T5 = Piece("T5", _T5_squares) + * cdef Piece _U5 = Piece("U5", _U5_squares) # <<<<<<<<<<<<<< + * cdef Piece _V5 = Piece("V5", _V5_squares) + * cdef Piece _W5 = Piece("W5", _W5_squares) +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_U5, __pyx_v_10blokus_gym_4core_13blokus_cython__U5_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 297, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__U5); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__U5, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":298 + * cdef Piece _T5 = Piece("T5", _T5_squares) + * cdef Piece _U5 = Piece("U5", _U5_squares) + * cdef Piece _V5 = Piece("V5", _V5_squares) # <<<<<<<<<<<<<< + * cdef Piece _W5 = Piece("W5", _W5_squares) + * cdef Piece _Z5 = Piece("Z5", _Z5_squares) +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_V5, __pyx_v_10blokus_gym_4core_13blokus_cython__V5_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 298, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__V5); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__V5, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":299 + * cdef Piece _U5 = Piece("U5", _U5_squares) + * cdef Piece _V5 = Piece("V5", _V5_squares) + * cdef Piece _W5 = Piece("W5", _W5_squares) # <<<<<<<<<<<<<< + * cdef Piece _Z5 = Piece("Z5", _Z5_squares) + * cdef Piece _F5 = Piece("F5", _F5_squares) +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_W5, __pyx_v_10blokus_gym_4core_13blokus_cython__W5_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 299, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__W5); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__W5, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":300 + * cdef Piece _V5 = Piece("V5", _V5_squares) + * cdef Piece _W5 = Piece("W5", _W5_squares) + * cdef Piece _Z5 = Piece("Z5", _Z5_squares) # <<<<<<<<<<<<<< + * cdef Piece _F5 = Piece("F5", _F5_squares) + * cdef Piece _X5 = Piece("X5", _X5_squares) +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_Z5, __pyx_v_10blokus_gym_4core_13blokus_cython__Z5_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 300, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__Z5); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__Z5, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":301 + * cdef Piece _W5 = Piece("W5", _W5_squares) + * cdef Piece _Z5 = Piece("Z5", _Z5_squares) + * cdef Piece _F5 = Piece("F5", _F5_squares) # <<<<<<<<<<<<<< + * cdef Piece _X5 = Piece("X5", _X5_squares) + * cdef Piece _P5 = Piece("P5", _P5_squares) +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_F5, __pyx_v_10blokus_gym_4core_13blokus_cython__F5_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 301, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__F5); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__F5, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":302 + * cdef Piece _Z5 = Piece("Z5", _Z5_squares) + * cdef Piece _F5 = Piece("F5", _F5_squares) + * cdef Piece _X5 = Piece("X5", _X5_squares) # <<<<<<<<<<<<<< + * cdef Piece _P5 = Piece("P5", _P5_squares) + * +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_X5, __pyx_v_10blokus_gym_4core_13blokus_cython__X5_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 302, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__X5); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__X5, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":303 + * cdef Piece _F5 = Piece("F5", _F5_squares) + * cdef Piece _X5 = Piece("X5", _X5_squares) + * cdef Piece _P5 = Piece("P5", _P5_squares) # <<<<<<<<<<<<<< + * + * cdef list STANDARD_PIECES = [ +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_P5, __pyx_v_10blokus_gym_4core_13blokus_cython__P5_squares}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_Piece, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 303, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__P5); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython__P5, ((struct __pyx_obj_10blokus_gym_4core_13blokus_cython_Piece *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":305 + * cdef Piece _P5 = Piece("P5", _P5_squares) + * + * cdef list STANDARD_PIECES = [ # <<<<<<<<<<<<<< + * _I1, _I2, _I3, _V3, _I4, _L4, _T4, _S4, _O4, + * _I5, _L5, _Y5, _N5, _T5, _U5, _V5, _W5, _Z5, _F5, _X5, _P5 +*/ + __pyx_t_4 = __Pyx_PyList_Pack(21, ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__I1), ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__I2), ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__I3), ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__V3), ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__I4), ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__L4), ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__T4), ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__S4), ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__O4), ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__I5), ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__L5), ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__Y5), ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__N5), ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__T5), ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__U5), ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__V5), ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__W5), ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__Z5), ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__F5), ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__X5), ((PyObject *)__pyx_v_10blokus_gym_4core_13blokus_cython__P5)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 305, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_v_10blokus_gym_4core_13blokus_cython_STANDARD_PIECES); + __Pyx_DECREF_SET(__pyx_v_10blokus_gym_4core_13blokus_cython_STANDARD_PIECES, ((PyObject*)__pyx_t_4)); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_11PlayerState_3__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PlayerState___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[32])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < (0)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_PlayerState, (type(self), 0x820c4ca, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_PlayerState__set_state(self, __pyx_state) +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_11PlayerState_5__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_PlayerState___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[33])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_PlayerState, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < (0)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":495 + * return len(self._action_moves) + * + * def get_move(self, int action) -> Move: # <<<<<<<<<<<<<< + * return self._action_moves[action] + * +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_Move) < (0)) __PYX_ERR(0, 495, __pyx_L1_error) + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_3get_move, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_BlokusGame_get_move, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[34])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame, __pyx_mstate_global->__pyx_n_u_get_move, __pyx_t_5) < (0)) __PYX_ERR(0, 495, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":498 + * return self._action_moves[action] + * + * def get_action(self, Move move) -> int: # <<<<<<<<<<<<<< + * return self._move_to_action[(move.piece_id, move.orientation_id, move.x, move.y)] + * +*/ + __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 498, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_int) < (0)) __PYX_ERR(0, 498, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_5get_action, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_BlokusGame_get_action, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[35])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 498, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame, __pyx_mstate_global->__pyx_n_u_get_action, __pyx_t_4) < (0)) __PYX_ERR(0, 498, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":501 + * return self._move_to_action[(move.piece_id, move.orientation_id, move.x, move.y)] + * + * def reset(self) -> None: # <<<<<<<<<<<<<< + * """Reset the game to its initial state.""" + * self.board = Board(self.board_size) +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 501, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < (0)) __PYX_ERR(0, 501, __pyx_L1_error) + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_7reset, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_BlokusGame_reset, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[36])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 501, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame, __pyx_mstate_global->__pyx_n_u_reset, __pyx_t_5) < (0)) __PYX_ERR(0, 501, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":540 + * return result + * + * cpdef bint valid_move(self, int player_idx, Move move): # <<<<<<<<<<<<<< + * """Check if a move is valid for the given player.""" + * cdef PlayerState player = self.players[player_idx] +*/ + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_9valid_move, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_BlokusGame_valid_move, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[37])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 540, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame, __pyx_mstate_global->__pyx_n_u_valid_move, __pyx_t_5) < (0)) __PYX_ERR(0, 540, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":592 + * return True + * + * cpdef get_valid_actions(self, int player_idx): # <<<<<<<<<<<<<< + * """Get a boolean mask of valid actions for the given player.""" + * cdef PlayerState player = self.players[player_idx] +*/ + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_11get_valid_actions, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_BlokusGame_get_valid_actions, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[38])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame, __pyx_mstate_global->__pyx_n_u_get_valid_actions, __pyx_t_5) < (0)) __PYX_ERR(0, 592, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":668 + * return mask + * + * cpdef bint has_valid_moves(self, int player_idx): # <<<<<<<<<<<<<< + * """Check if a player has any valid moves.""" + * cdef PlayerState player = self.players[player_idx] +*/ + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_13has_valid_moves, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_BlokusGame_has_valid_moves, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[39])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame, __pyx_mstate_global->__pyx_n_u_has_valid_moves, __pyx_t_5) < (0)) __PYX_ERR(0, 668, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":687 + * return False + * + * def apply_move(self, int player_idx, Move move) -> None: # <<<<<<<<<<<<<< + * """Apply a move to the game state. Does not validate.""" + * cdef PlayerState player = self.players[player_idx] +*/ + __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 687, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < (0)) __PYX_ERR(0, 687, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_15apply_move, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_BlokusGame_apply_move, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[40])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 687, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame, __pyx_mstate_global->__pyx_n_u_apply_move, __pyx_t_4) < (0)) __PYX_ERR(0, 687, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":715 + * self._check_game_over() + * + * def play_move(self, int player_idx, int action) -> bint: # <<<<<<<<<<<<<< + * """Play an action for the given player. Validates first.""" + * cdef Move move = self._action_moves[action] +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 715, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_bint) < (0)) __PYX_ERR(0, 715, __pyx_L1_error) + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_17play_move, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_BlokusGame_play_move, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[41])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 715, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame, __pyx_mstate_global->__pyx_n_u_play_move, __pyx_t_5) < (0)) __PYX_ERR(0, 715, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":725 + * return True + * + * def next_player(self): # <<<<<<<<<<<<<< + * """Advance to the next player who can still move. + * +*/ + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_19next_player, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_BlokusGame_next_player, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[42])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 725, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame, __pyx_mstate_global->__pyx_n_u_next_player, __pyx_t_5) < (0)) __PYX_ERR(0, 725, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":744 + * return self.current_player + * + * def _check_game_over(self) -> None: # <<<<<<<<<<<<<< + * """Check if the game is over.""" + * cdef PlayerState player +*/ + __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 744, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_None) < (0)) __PYX_ERR(0, 744, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_21_check_game_over, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_BlokusGame__check_game_over, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[43])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 744, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame, __pyx_mstate_global->__pyx_n_u_check_game_over, __pyx_t_4) < (0)) __PYX_ERR(0, 744, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":760 + * self.game_over = True + * + * def get_state(self) -> dict: # <<<<<<<<<<<<<< + * """Get the current game state as a dictionary.""" + * return { +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 760, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_dict_2) < (0)) __PYX_ERR(0, 760, __pyx_L1_error) + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_23get_state, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_BlokusGame_get_state, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[44])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 760, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_5, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame, __pyx_mstate_global->__pyx_n_u_get_state, __pyx_t_5) < (0)) __PYX_ERR(0, 760, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":780 + * } + * + * def copy(self) -> BlokusGame: # <<<<<<<<<<<<<< + * """Create a deep copy of the game.""" + * cdef BlokusGame new_game = BlokusGame( +*/ + __pyx_t_5 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 780, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_return, __pyx_mstate_global->__pyx_n_u_BlokusGame) < (0)) __PYX_ERR(0, 780, __pyx_L1_error) + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_25copy, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_BlokusGame_copy, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[45])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 780, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetAnnotationsDict(__pyx_t_4, __pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame, __pyx_mstate_global->__pyx_n_u_copy, __pyx_t_4) < (0)) __PYX_ERR(0, 780, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_27__reduce_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_BlokusGame___reduce_cython, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[46])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame, __pyx_mstate_global->__pyx_n_u_reduce_cython, __pyx_t_4) < (0)) __PYX_ERR(1, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_BlokusGame, (type(self), 0x2eba6e9, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_BlokusGame__set_state(self, __pyx_state) +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_10BlokusGame_29__setstate_cython__, __Pyx_CYFUNCTION_CCLASS, __pyx_mstate_global->__pyx_n_u_BlokusGame___setstate_cython, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[47])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_ptype_10blokus_gym_4core_13blokus_cython_BlokusGame, __pyx_mstate_global->__pyx_n_u_setstate_cython, __pyx_t_4) < (0)) __PYX_ERR(1, 16, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_Board(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x0510d2c, 0x0b84c10, 0x0bc2a6c, b'_occupied_cache, grid, size') +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_1__pyx_unpickle_Board, 0, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Board, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[48])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Board, __pyx_t_4) < (0)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":1 + * cdef extern from *: # <<<<<<<<<<<<<< + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_3__pyx_unpickle_Move, 0, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Move, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[49])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Move, __pyx_t_4) < (0)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_PieceOrientation(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0xf86ecb3, 0x1b2f35d, 0x9c26469, b'corners, orientation_id, piece_id, squares') +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_5__pyx_unpickle_PieceOrientation, 0, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_PieceOrientation, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[50])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_PieceOrientation, __pyx_t_4) < (0)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":1 + * cdef extern from *: # <<<<<<<<<<<<<< + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_7__pyx_unpickle_Piece, 0, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Piece, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[51])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Piece, __pyx_t_4) < (0)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_PieceSet(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x0a4ef5f, 0x798f028, 0xb2ae89a, b'num_orientations, orientations, piece_id_map, piece_names, pieces') +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_9__pyx_unpickle_PieceSet, 0, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_PieceSet, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[52])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_PieceSet, __pyx_t_4) < (0)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":1 + * cdef extern from *: # <<<<<<<<<<<<<< + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_11__pyx_unpickle_PlayerState, 0, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_PlayerState, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[53])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_PlayerState, __pyx_t_4) < (0)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_BlokusGame(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x2eba6e9, 0xec864e3, 0x3965e13, b'_action_moves, _actions_by_piece, _move_to_action, _starting_corners, board, board_size, corner_rule, current_player, game_over, num_players, piece_set, players, rounds') +*/ + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_10blokus_gym_4core_13blokus_cython_13__pyx_unpickle_BlokusGame, 0, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_BlokusGame, NULL, __pyx_mstate_global->__pyx_n_u_blokus_gym_core_blokus_cython, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[54])); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_BlokusGame, __pyx_t_4) < (0)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "blokus_gym/core/blokus_cython.pyx":1 + * #!/usr/bin/env python3 # <<<<<<<<<<<<<< + * # Combined Cython implementation of Blokus game engine + * # Compile with: python setup_cython.py build_ext --inplace +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_test, __pyx_t_4) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + if (__pyx_m) { + if (__pyx_mstate->__pyx_d && stringtab_initialized) { + __Pyx_AddTraceback("init blokus_gym.core.blokus_cython", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + #if !CYTHON_USE_MODULE_STATE + Py_CLEAR(__pyx_m); + #else + Py_DECREF(__pyx_m); + if (pystate_addmodule_run) { + PyObject *tp, *value, *tb; + PyErr_Fetch(&tp, &value, &tb); + PyState_RemoveModule(&__pyx_moduledef); + PyErr_Restore(tp, value, tb); + } + #endif + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init blokus_gym.core.blokus_cython"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #else + return __pyx_m; + #endif +} +/* #### Code section: pystring_table ### */ +/* #### Code section: cached_builtins ### */ + +static int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate) { + CYTHON_UNUSED_VAR(__pyx_mstate); + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(0, 235, __pyx_L1_error) + __pyx_builtin_sum = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_sum); if (!__pyx_builtin_sum) __PYX_ERR(0, 241, __pyx_L1_error) + __pyx_builtin_min = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_min); if (!__pyx_builtin_min) __PYX_ERR(0, 351, __pyx_L1_error) + __pyx_builtin_max = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_max); if (!__pyx_builtin_max) __PYX_ERR(0, 481, __pyx_L1_error) + __pyx_builtin___import__ = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_import); if (!__pyx_builtin___import__) __PYX_ERR(1, 109, __pyx_L1_error) + __pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(1, 418, __pyx_L1_error) + __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_id); if (!__pyx_builtin_id) __PYX_ERR(1, 628, __pyx_L1_error) + + /* Cached unbound methods */ + __pyx_mstate->__pyx_umethod_PyDict_Type_items.type = (PyObject*)&PyDict_Type; + __pyx_mstate->__pyx_umethod_PyDict_Type_items.method_name = &__pyx_mstate->__pyx_n_u_items; + __pyx_mstate->__pyx_umethod_PyDict_Type_pop.type = (PyObject*)&PyDict_Type; + __pyx_mstate->__pyx_umethod_PyDict_Type_pop.method_name = &__pyx_mstate->__pyx_n_u_pop; + __pyx_mstate->__pyx_umethod_PyDict_Type_values.type = (PyObject*)&PyDict_Type; + __pyx_mstate->__pyx_umethod_PyDict_Type_values.method_name = &__pyx_mstate->__pyx_n_u_values; + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: cached_constants ### */ + +static int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "View.MemoryView":592 + * 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_mstate_global->__pyx_tuple[0] = PyTuple_New(1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[0])) __PYX_ERR(1, 592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[0]); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_mstate_global->__pyx_tuple[0], 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(1, 592, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[0]); + + /* "View.MemoryView":689 + * tup = index if isinstance(index, tuple) else (index,) + * + * result = [slice(None)] * ndim # <<<<<<<<<<<<<< + * have_slices = False + * seen_ellipsis = False +*/ + __pyx_mstate_global->__pyx_slice[0] = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_slice[0])) __PYX_ERR(1, 689, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_slice[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[0]); + + /* "blokus_gym/core/blokus_cython.pyx":122 + * + * for x, y in player_squares: + * for dx, dy in [(-1, -1), (1, -1), (-1, 1), (1, 1)]: # <<<<<<<<<<<<<< + * cx, cy = x + dx, y + dy + * if 0 <= cx < size and 0 <= cy < size and grid_view[cy, cx] == 0: +*/ + __pyx_mstate_global->__pyx_tuple[1] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_neg_1, __pyx_mstate_global->__pyx_int_neg_1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[1])) __PYX_ERR(0, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[1]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[1]); + __pyx_mstate_global->__pyx_tuple[2] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_1, __pyx_mstate_global->__pyx_int_neg_1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[2])) __PYX_ERR(0, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[2]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[2]); + __pyx_mstate_global->__pyx_tuple[3] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_neg_1, __pyx_mstate_global->__pyx_int_1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[3])) __PYX_ERR(0, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[3]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[3]); + __pyx_mstate_global->__pyx_tuple[4] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_1, __pyx_mstate_global->__pyx_int_1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[4])) __PYX_ERR(0, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[4]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[4]); + __pyx_mstate_global->__pyx_tuple[5] = PyTuple_Pack(4, __pyx_mstate_global->__pyx_tuple[1], __pyx_mstate_global->__pyx_tuple[2], __pyx_mstate_global->__pyx_tuple[3], __pyx_mstate_global->__pyx_tuple[4]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[5])) __PYX_ERR(0, 122, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[5]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[5]); + + /* "blokus_gym/core/blokus_cython.pyx":441 + * max_idx = board_size - 1 + * self._starting_corners = [ + * (0, 0), # <<<<<<<<<<<<<< + * (0, max_idx), + * (max_idx, 0), +*/ + __pyx_mstate_global->__pyx_tuple[6] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_int_0); if (unlikely(!__pyx_mstate_global->__pyx_tuple[6])) __PYX_ERR(0, 441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[6]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[6]); + + /* "blokus_gym/core/blokus_cython.pyx":573 + * # Rule 5: No edge adjacency with same-color pieces (inline for speed) + * for x, y in placed_squares: + * for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: # <<<<<<<<<<<<<< + * if self.board.in_bounds(x + dx, y + dy): + * if self.board.get_cell(x + dx, y + dy) == player_board_idx: +*/ + __pyx_mstate_global->__pyx_tuple[7] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_neg_1, __pyx_mstate_global->__pyx_int_0); if (unlikely(!__pyx_mstate_global->__pyx_tuple[7])) __PYX_ERR(0, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[7]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[7]); + __pyx_mstate_global->__pyx_tuple[8] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_1, __pyx_mstate_global->__pyx_int_0); if (unlikely(!__pyx_mstate_global->__pyx_tuple[8])) __PYX_ERR(0, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[8]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[8]); + __pyx_mstate_global->__pyx_tuple[9] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_int_neg_1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[9])) __PYX_ERR(0, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[9]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[9]); + __pyx_mstate_global->__pyx_tuple[10] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_int_1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[10])) __PYX_ERR(0, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[10]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[10]); + __pyx_mstate_global->__pyx_tuple[11] = PyTuple_Pack(4, __pyx_mstate_global->__pyx_tuple[7], __pyx_mstate_global->__pyx_tuple[8], __pyx_mstate_global->__pyx_tuple[9], __pyx_mstate_global->__pyx_tuple[10]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[11])) __PYX_ERR(0, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[11]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[11]); + + /* "blokus_gym/core/blokus_cython.pyx":261 + * # ------------------------------------------------------------------- + * + * cdef frozenset _I1_squares = frozenset([(0, 0)]) # <<<<<<<<<<<<<< + * cdef frozenset _I2_squares = frozenset([(0, 0), (0, 1)]) + * cdef frozenset _I3_squares = frozenset([(0, 0), (0, 1), (0, 2)]) +*/ + __pyx_mstate_global->__pyx_tuple[12] = PyTuple_Pack(1, __pyx_mstate_global->__pyx_tuple[6]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[12])) __PYX_ERR(0, 261, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[12]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[12]); + + /* "blokus_gym/core/blokus_cython.pyx":262 + * + * cdef frozenset _I1_squares = frozenset([(0, 0)]) + * cdef frozenset _I2_squares = frozenset([(0, 0), (0, 1)]) # <<<<<<<<<<<<<< + * cdef frozenset _I3_squares = frozenset([(0, 0), (0, 1), (0, 2)]) + * cdef frozenset _V3_squares = frozenset([(0, 0), (1, 0), (0, 1)]) +*/ + __pyx_mstate_global->__pyx_tuple[13] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_tuple[6], __pyx_mstate_global->__pyx_tuple[10]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[13])) __PYX_ERR(0, 262, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[13]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[13]); + + /* "blokus_gym/core/blokus_cython.pyx":263 + * cdef frozenset _I1_squares = frozenset([(0, 0)]) + * cdef frozenset _I2_squares = frozenset([(0, 0), (0, 1)]) + * cdef frozenset _I3_squares = frozenset([(0, 0), (0, 1), (0, 2)]) # <<<<<<<<<<<<<< + * cdef frozenset _V3_squares = frozenset([(0, 0), (1, 0), (0, 1)]) + * cdef frozenset _I4_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3)]) +*/ + __pyx_mstate_global->__pyx_tuple[14] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_int_2); if (unlikely(!__pyx_mstate_global->__pyx_tuple[14])) __PYX_ERR(0, 263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[14]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[14]); + __pyx_mstate_global->__pyx_tuple[15] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_tuple[6], __pyx_mstate_global->__pyx_tuple[10], __pyx_mstate_global->__pyx_tuple[14]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[15])) __PYX_ERR(0, 263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[15]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[15]); + + /* "blokus_gym/core/blokus_cython.pyx":264 + * cdef frozenset _I2_squares = frozenset([(0, 0), (0, 1)]) + * cdef frozenset _I3_squares = frozenset([(0, 0), (0, 1), (0, 2)]) + * cdef frozenset _V3_squares = frozenset([(0, 0), (1, 0), (0, 1)]) # <<<<<<<<<<<<<< + * cdef frozenset _I4_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3)]) + * cdef frozenset _L4_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0)]) +*/ + __pyx_mstate_global->__pyx_tuple[16] = PyTuple_Pack(3, __pyx_mstate_global->__pyx_tuple[6], __pyx_mstate_global->__pyx_tuple[8], __pyx_mstate_global->__pyx_tuple[10]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[16])) __PYX_ERR(0, 264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[16]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[16]); + + /* "blokus_gym/core/blokus_cython.pyx":265 + * cdef frozenset _I3_squares = frozenset([(0, 0), (0, 1), (0, 2)]) + * cdef frozenset _V3_squares = frozenset([(0, 0), (1, 0), (0, 1)]) + * cdef frozenset _I4_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3)]) # <<<<<<<<<<<<<< + * cdef frozenset _L4_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0)]) + * cdef frozenset _T4_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1)]) +*/ + __pyx_mstate_global->__pyx_tuple[17] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_int_3); if (unlikely(!__pyx_mstate_global->__pyx_tuple[17])) __PYX_ERR(0, 265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[17]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[17]); + __pyx_mstate_global->__pyx_tuple[18] = PyTuple_Pack(4, __pyx_mstate_global->__pyx_tuple[6], __pyx_mstate_global->__pyx_tuple[10], __pyx_mstate_global->__pyx_tuple[14], __pyx_mstate_global->__pyx_tuple[17]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[18])) __PYX_ERR(0, 265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[18]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[18]); + + /* "blokus_gym/core/blokus_cython.pyx":266 + * cdef frozenset _V3_squares = frozenset([(0, 0), (1, 0), (0, 1)]) + * cdef frozenset _I4_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3)]) + * cdef frozenset _L4_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0)]) # <<<<<<<<<<<<<< + * cdef frozenset _T4_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1)]) + * cdef frozenset _S4_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1)]) +*/ + __pyx_mstate_global->__pyx_tuple[19] = PyTuple_Pack(4, __pyx_mstate_global->__pyx_tuple[6], __pyx_mstate_global->__pyx_tuple[10], __pyx_mstate_global->__pyx_tuple[14], __pyx_mstate_global->__pyx_tuple[8]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[19])) __PYX_ERR(0, 266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[19]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[19]); + + /* "blokus_gym/core/blokus_cython.pyx":267 + * cdef frozenset _I4_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3)]) + * cdef frozenset _L4_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0)]) + * cdef frozenset _T4_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1)]) # <<<<<<<<<<<<<< + * cdef frozenset _S4_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1)]) + * cdef frozenset _O4_squares = frozenset([(0, 0), (1, 0), (0, 1), (1, 1)]) +*/ + __pyx_mstate_global->__pyx_tuple[20] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_2, __pyx_mstate_global->__pyx_int_0); if (unlikely(!__pyx_mstate_global->__pyx_tuple[20])) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[20]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[20]); + __pyx_mstate_global->__pyx_tuple[21] = PyTuple_Pack(4, __pyx_mstate_global->__pyx_tuple[6], __pyx_mstate_global->__pyx_tuple[8], __pyx_mstate_global->__pyx_tuple[20], __pyx_mstate_global->__pyx_tuple[4]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[21])) __PYX_ERR(0, 267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[21]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[21]); + + /* "blokus_gym/core/blokus_cython.pyx":268 + * cdef frozenset _L4_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0)]) + * cdef frozenset _T4_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1)]) + * cdef frozenset _S4_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1)]) # <<<<<<<<<<<<<< + * cdef frozenset _O4_squares = frozenset([(0, 0), (1, 0), (0, 1), (1, 1)]) + * cdef frozenset _I5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4)]) +*/ + __pyx_mstate_global->__pyx_tuple[22] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_2, __pyx_mstate_global->__pyx_int_1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[22])) __PYX_ERR(0, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[22]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[22]); + __pyx_mstate_global->__pyx_tuple[23] = PyTuple_Pack(4, __pyx_mstate_global->__pyx_tuple[6], __pyx_mstate_global->__pyx_tuple[8], __pyx_mstate_global->__pyx_tuple[4], __pyx_mstate_global->__pyx_tuple[22]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[23])) __PYX_ERR(0, 268, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[23]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[23]); + + /* "blokus_gym/core/blokus_cython.pyx":269 + * cdef frozenset _T4_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1)]) + * cdef frozenset _S4_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1)]) + * cdef frozenset _O4_squares = frozenset([(0, 0), (1, 0), (0, 1), (1, 1)]) # <<<<<<<<<<<<<< + * cdef frozenset _I5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4)]) + * cdef frozenset _L5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 0)]) +*/ + __pyx_mstate_global->__pyx_tuple[24] = PyTuple_Pack(4, __pyx_mstate_global->__pyx_tuple[6], __pyx_mstate_global->__pyx_tuple[8], __pyx_mstate_global->__pyx_tuple[10], __pyx_mstate_global->__pyx_tuple[4]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[24])) __PYX_ERR(0, 269, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[24]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[24]); + + /* "blokus_gym/core/blokus_cython.pyx":270 + * cdef frozenset _S4_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1)]) + * cdef frozenset _O4_squares = frozenset([(0, 0), (1, 0), (0, 1), (1, 1)]) + * cdef frozenset _I5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4)]) # <<<<<<<<<<<<<< + * cdef frozenset _L5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 0)]) + * cdef frozenset _Y5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1)]) +*/ + __pyx_mstate_global->__pyx_tuple[25] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_0, __pyx_mstate_global->__pyx_int_4); if (unlikely(!__pyx_mstate_global->__pyx_tuple[25])) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[25]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[25]); + __pyx_mstate_global->__pyx_tuple[26] = PyTuple_Pack(5, __pyx_mstate_global->__pyx_tuple[6], __pyx_mstate_global->__pyx_tuple[10], __pyx_mstate_global->__pyx_tuple[14], __pyx_mstate_global->__pyx_tuple[17], __pyx_mstate_global->__pyx_tuple[25]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[26])) __PYX_ERR(0, 270, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[26]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[26]); + + /* "blokus_gym/core/blokus_cython.pyx":271 + * cdef frozenset _O4_squares = frozenset([(0, 0), (1, 0), (0, 1), (1, 1)]) + * cdef frozenset _I5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4)]) + * cdef frozenset _L5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 0)]) # <<<<<<<<<<<<<< + * cdef frozenset _Y5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1)]) + * cdef frozenset _N5_squares = frozenset([(0, 0), (1, 0), (2, 0), (2, 1), (3, 1)]) +*/ + __pyx_mstate_global->__pyx_tuple[27] = PyTuple_Pack(5, __pyx_mstate_global->__pyx_tuple[6], __pyx_mstate_global->__pyx_tuple[10], __pyx_mstate_global->__pyx_tuple[14], __pyx_mstate_global->__pyx_tuple[17], __pyx_mstate_global->__pyx_tuple[8]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[27])) __PYX_ERR(0, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[27]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[27]); + + /* "blokus_gym/core/blokus_cython.pyx":272 + * cdef frozenset _I5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4)]) + * cdef frozenset _L5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 0)]) + * cdef frozenset _Y5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1)]) # <<<<<<<<<<<<<< + * cdef frozenset _N5_squares = frozenset([(0, 0), (1, 0), (2, 0), (2, 1), (3, 1)]) + * cdef frozenset _T5_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1), (1, 2)]) +*/ + __pyx_mstate_global->__pyx_tuple[28] = PyTuple_Pack(5, __pyx_mstate_global->__pyx_tuple[6], __pyx_mstate_global->__pyx_tuple[10], __pyx_mstate_global->__pyx_tuple[14], __pyx_mstate_global->__pyx_tuple[17], __pyx_mstate_global->__pyx_tuple[4]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[28])) __PYX_ERR(0, 272, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[28]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[28]); + + /* "blokus_gym/core/blokus_cython.pyx":273 + * cdef frozenset _L5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 0)]) + * cdef frozenset _Y5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1)]) + * cdef frozenset _N5_squares = frozenset([(0, 0), (1, 0), (2, 0), (2, 1), (3, 1)]) # <<<<<<<<<<<<<< + * cdef frozenset _T5_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1), (1, 2)]) + * cdef frozenset _U5_squares = frozenset([(0, 0), (2, 0), (0, 1), (1, 1), (2, 1)]) +*/ + __pyx_mstate_global->__pyx_tuple[29] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_3, __pyx_mstate_global->__pyx_int_1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[29])) __PYX_ERR(0, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[29]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[29]); + __pyx_mstate_global->__pyx_tuple[30] = PyTuple_Pack(5, __pyx_mstate_global->__pyx_tuple[6], __pyx_mstate_global->__pyx_tuple[8], __pyx_mstate_global->__pyx_tuple[20], __pyx_mstate_global->__pyx_tuple[22], __pyx_mstate_global->__pyx_tuple[29]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[30])) __PYX_ERR(0, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[30]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[30]); + + /* "blokus_gym/core/blokus_cython.pyx":274 + * cdef frozenset _Y5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1)]) + * cdef frozenset _N5_squares = frozenset([(0, 0), (1, 0), (2, 0), (2, 1), (3, 1)]) + * cdef frozenset _T5_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1), (1, 2)]) # <<<<<<<<<<<<<< + * cdef frozenset _U5_squares = frozenset([(0, 0), (2, 0), (0, 1), (1, 1), (2, 1)]) + * cdef frozenset _V5_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0), (2, 0)]) +*/ + __pyx_mstate_global->__pyx_tuple[31] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_1, __pyx_mstate_global->__pyx_int_2); if (unlikely(!__pyx_mstate_global->__pyx_tuple[31])) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[31]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[31]); + __pyx_mstate_global->__pyx_tuple[32] = PyTuple_Pack(5, __pyx_mstate_global->__pyx_tuple[6], __pyx_mstate_global->__pyx_tuple[8], __pyx_mstate_global->__pyx_tuple[20], __pyx_mstate_global->__pyx_tuple[4], __pyx_mstate_global->__pyx_tuple[31]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[32])) __PYX_ERR(0, 274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[32]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[32]); + + /* "blokus_gym/core/blokus_cython.pyx":275 + * cdef frozenset _N5_squares = frozenset([(0, 0), (1, 0), (2, 0), (2, 1), (3, 1)]) + * cdef frozenset _T5_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1), (1, 2)]) + * cdef frozenset _U5_squares = frozenset([(0, 0), (2, 0), (0, 1), (1, 1), (2, 1)]) # <<<<<<<<<<<<<< + * cdef frozenset _V5_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0), (2, 0)]) + * cdef frozenset _W5_squares = frozenset([(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)]) +*/ + __pyx_mstate_global->__pyx_tuple[33] = PyTuple_Pack(5, __pyx_mstate_global->__pyx_tuple[6], __pyx_mstate_global->__pyx_tuple[20], __pyx_mstate_global->__pyx_tuple[10], __pyx_mstate_global->__pyx_tuple[4], __pyx_mstate_global->__pyx_tuple[22]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[33])) __PYX_ERR(0, 275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[33]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[33]); + + /* "blokus_gym/core/blokus_cython.pyx":276 + * cdef frozenset _T5_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1), (1, 2)]) + * cdef frozenset _U5_squares = frozenset([(0, 0), (2, 0), (0, 1), (1, 1), (2, 1)]) + * cdef frozenset _V5_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0), (2, 0)]) # <<<<<<<<<<<<<< + * cdef frozenset _W5_squares = frozenset([(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)]) + * cdef frozenset _Z5_squares = frozenset([(0, 0), (1, 0), (1, 1), (1, 2), (2, 2)]) +*/ + __pyx_mstate_global->__pyx_tuple[34] = PyTuple_Pack(5, __pyx_mstate_global->__pyx_tuple[6], __pyx_mstate_global->__pyx_tuple[10], __pyx_mstate_global->__pyx_tuple[14], __pyx_mstate_global->__pyx_tuple[8], __pyx_mstate_global->__pyx_tuple[20]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[34])) __PYX_ERR(0, 276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[34]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[34]); + + /* "blokus_gym/core/blokus_cython.pyx":277 + * cdef frozenset _U5_squares = frozenset([(0, 0), (2, 0), (0, 1), (1, 1), (2, 1)]) + * cdef frozenset _V5_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0), (2, 0)]) + * cdef frozenset _W5_squares = frozenset([(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)]) # <<<<<<<<<<<<<< + * cdef frozenset _Z5_squares = frozenset([(0, 0), (1, 0), (1, 1), (1, 2), (2, 2)]) + * cdef frozenset _F5_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1), (1, 2)]) +*/ + __pyx_mstate_global->__pyx_tuple[35] = PyTuple_Pack(5, __pyx_mstate_global->__pyx_tuple[6], __pyx_mstate_global->__pyx_tuple[10], __pyx_mstate_global->__pyx_tuple[8], __pyx_mstate_global->__pyx_tuple[4], __pyx_mstate_global->__pyx_tuple[20]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[35])) __PYX_ERR(0, 277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[35]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[35]); + + /* "blokus_gym/core/blokus_cython.pyx":278 + * cdef frozenset _V5_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0), (2, 0)]) + * cdef frozenset _W5_squares = frozenset([(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)]) + * cdef frozenset _Z5_squares = frozenset([(0, 0), (1, 0), (1, 1), (1, 2), (2, 2)]) # <<<<<<<<<<<<<< + * cdef frozenset _F5_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1), (1, 2)]) + * cdef frozenset _X5_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1), (1, -1)]) +*/ + __pyx_mstate_global->__pyx_tuple[36] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_int_2, __pyx_mstate_global->__pyx_int_2); if (unlikely(!__pyx_mstate_global->__pyx_tuple[36])) __PYX_ERR(0, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[36]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[36]); + __pyx_mstate_global->__pyx_tuple[37] = PyTuple_Pack(5, __pyx_mstate_global->__pyx_tuple[6], __pyx_mstate_global->__pyx_tuple[8], __pyx_mstate_global->__pyx_tuple[4], __pyx_mstate_global->__pyx_tuple[31], __pyx_mstate_global->__pyx_tuple[36]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[37])) __PYX_ERR(0, 278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[37]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[37]); + + /* "blokus_gym/core/blokus_cython.pyx":279 + * cdef frozenset _W5_squares = frozenset([(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)]) + * cdef frozenset _Z5_squares = frozenset([(0, 0), (1, 0), (1, 1), (1, 2), (2, 2)]) + * cdef frozenset _F5_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1), (1, 2)]) # <<<<<<<<<<<<<< + * cdef frozenset _X5_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1), (1, -1)]) + * cdef frozenset _P5_squares = frozenset([(0, 0), (1, 0), (0, 1), (1, 1), (0, 2)]) +*/ + __pyx_mstate_global->__pyx_tuple[38] = PyTuple_Pack(5, __pyx_mstate_global->__pyx_tuple[6], __pyx_mstate_global->__pyx_tuple[8], __pyx_mstate_global->__pyx_tuple[4], __pyx_mstate_global->__pyx_tuple[22], __pyx_mstate_global->__pyx_tuple[31]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[38])) __PYX_ERR(0, 279, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[38]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[38]); + + /* "blokus_gym/core/blokus_cython.pyx":280 + * cdef frozenset _Z5_squares = frozenset([(0, 0), (1, 0), (1, 1), (1, 2), (2, 2)]) + * cdef frozenset _F5_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1), (1, 2)]) + * cdef frozenset _X5_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1), (1, -1)]) # <<<<<<<<<<<<<< + * cdef frozenset _P5_squares = frozenset([(0, 0), (1, 0), (0, 1), (1, 1), (0, 2)]) + * +*/ + __pyx_mstate_global->__pyx_tuple[39] = PyTuple_Pack(5, __pyx_mstate_global->__pyx_tuple[6], __pyx_mstate_global->__pyx_tuple[8], __pyx_mstate_global->__pyx_tuple[20], __pyx_mstate_global->__pyx_tuple[4], __pyx_mstate_global->__pyx_tuple[2]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[39])) __PYX_ERR(0, 280, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[39]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[39]); + + /* "blokus_gym/core/blokus_cython.pyx":281 + * cdef frozenset _F5_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1), (1, 2)]) + * cdef frozenset _X5_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1), (1, -1)]) + * cdef frozenset _P5_squares = frozenset([(0, 0), (1, 0), (0, 1), (1, 1), (0, 2)]) # <<<<<<<<<<<<<< + * + * cdef Piece _I1 = Piece("I1", _I1_squares) +*/ + __pyx_mstate_global->__pyx_tuple[40] = PyTuple_Pack(5, __pyx_mstate_global->__pyx_tuple[6], __pyx_mstate_global->__pyx_tuple[8], __pyx_mstate_global->__pyx_tuple[10], __pyx_mstate_global->__pyx_tuple[4], __pyx_mstate_global->__pyx_tuple[14]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[40])) __PYX_ERR(0, 281, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[40]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[40]); + #if CYTHON_IMMORTAL_CONSTANTS + { + PyObject **table = __pyx_mstate->__pyx_tuple; + for (Py_ssize_t i=0; i<41; ++i) { + #if PY_VERSION_HEX >= 0x030F0000 + PyUnstable_SetImmortal(table[i]); + #elif CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if ((PY_SSIZE_T_MAX <= _Py_IMMORTAL_REFCNT_LOCAL)) break; + #if PY_VERSION_HEX < 0x030E0000 + if (_Py_IsOwnedByCurrentThread(table[i]) && Py_REFCNT(table[i]) == 1) + #else + if (PyUnstable_Object_IsUniquelyReferenced(table[i])) + #endif + { + Py_SET_REFCNT(table[i], ((Py_ssize_t)_Py_IMMORTAL_REFCNT_LOCAL + 1)); + } + #else + if ((PY_SSIZE_T_MAX < _Py_IMMORTAL_INITIAL_REFCNT)) break; + Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); + #endif + } + } + #endif + #if CYTHON_IMMORTAL_CONSTANTS + { + PyObject **table = __pyx_mstate->__pyx_slice; + for (Py_ssize_t i=0; i<1; ++i) { + #if PY_VERSION_HEX >= 0x030F0000 + PyUnstable_SetImmortal(table[i]); + #elif CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if ((PY_SSIZE_T_MAX <= _Py_IMMORTAL_REFCNT_LOCAL)) break; + #if PY_VERSION_HEX < 0x030E0000 + if (_Py_IsOwnedByCurrentThread(table[i]) && Py_REFCNT(table[i]) == 1) + #else + if (PyUnstable_Object_IsUniquelyReferenced(table[i])) + #endif + { + Py_SET_REFCNT(table[i], ((Py_ssize_t)_Py_IMMORTAL_REFCNT_LOCAL + 1)); + } + #else + if ((PY_SSIZE_T_MAX < _Py_IMMORTAL_INITIAL_REFCNT)) break; + Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); + #endif + } + } + #endif + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} +/* #### Code section: init_constants ### */ + +static int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate) { + CYTHON_UNUSED_VAR(__pyx_mstate); + { + const struct { const unsigned int length: 9; } index[] = {{2},{35},{54},{37},{60},{24},{52},{26},{34},{33},{45},{22},{15},{11},{179},{37},{32},{1},{1},{1},{1},{2},{2},{1},{8},{5},{6},{33},{15},{23},{25},{7},{6},{2},{6},{35},{9},{30},{50},{39},{34},{8},{9},{7},{20},{32},{22},{14},{30},{37},{5},{10},{28},{30},{27},{50},{21},{15},{21},{19},{20},{28},{26},{22},{20},{16},{21},{5},{23},{25},{11},{14},{14},{18},{24},{25},{24},{17},{15},{14},{13},{11},{8},{2},{2},{2},{2},{2},{2},{2},{2},{4},{22},{24},{2},{4},{2},{2},{5},{16},{34},{36},{8},{26},{28},{25},{18},{21},{23},{25},{11},{29},{31},{20},{2},{8},{2},{2},{2},{2},{2},{15},{2},{2},{2},{2},{1},{3},{6},{15},{12},{10},{18},{16},{4},{4},{29},{10},{4},{1},{8},{16},{33},{9},{17},{5},{18},{5},{4},{11},{7},{5},{8},{14},{2},{2},{8},{4},{5},{5},{15},{2},{2},{6},{9},{5},{4},{5},{5},{6},{7},{8},{9},{7},{10},{8},{8},{12},{16},{9},{12},{18},{19},{18},{9},{17},{12},{9},{11},{11},{15},{1},{2},{3},{10},{9},{5},{25},{3},{4},{13},{8},{7},{5},{8},{4},{8},{3},{7},{3},{4},{10},{4},{4},{8},{4},{7},{8},{4},{8},{11},{41},{2},{11},{10},{11},{5},{1},{3},{6},{14},{1},{4},{5},{8},{6},{11},{5},{14},{14},{9},{6},{10},{14},{7},{3},{14},{12},{11},{10},{25},{20},{19},{19},{20},{31},{23},{26},{14},{12},{10},{17},{13},{8},{5},{6},{6},{6},{5},{4},{4},{3},{12},{10},{12},{19},{5},{4},{7},{5},{5},{4},{4},{6},{3},{8},{5},{6},{6},{12},{10},{5},{6},{1},{1},{5},{16},{11},{96},{77},{79},{144},{51},{11},{52},{187},{2},{113},{88},{384},{493},{110},{33},{67},{120},{107},{399},{111},{134},{169},{104},{11},{2},{60},{56},{68},{81},{188},{79},{16},{11},{11},{2},{55},{55},{58},{55},{55},{55},{2},{2},{11},{16},{164},{34},{16},{16},{1}}; + #if (CYTHON_COMPRESS_STRINGS) == 2 /* compression: bz2 (3853 bytes) */ +const char* const cstring = "BZh91AY&SY>2\322\305\000\003\325\177\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\300@@@@@@@@@@@@\000@\000`\017]\336\367\037/n5lmb@v\030\347J\3477l\333&\263Mk\271n\200C\340\000\003\203BP\205\022\207\250\365\036Si=OQ\372\246\365OS\3016\202f\206\023\003(\312\206\323)\352=\251\352\233(\331M\2216\243M6\2104\331'\246\231C\304A(\200\020\323Q\243)O\023\324\324\375P\315M\032\237\251\006\206F\332\201\017H\014\215\251\246 \014M\006\214\230\217H\332\233S\320\200\323\r4\320\210I\221\0104z\215=FOS\304\217P\003OP\0004\000\r\000\000\320\032\000\000\032\031\222\001&\244B\232\236\211\251\275Dm'\352G\250mCL\2004\0004\003@\000\365\006\200\000\006\215\000\032\000\032\032\035\r\006M4zz\237\252L\0020&\023\000\000!\211\246\230\201\221\264F\200z\214\004\300L!\220d\000\022(\"a\032LF\020dd\032\014\242\232?Rd\365\007\250\0004\000\000\000\000\000\000\032\000\034\311 f\223>h\260+]\265\240R\030\004\365\231\005\200\301\223\225\370\376\333\334\355\356h\335\r\274\310s\231\t\335\014\361\"C\232\020\361\026\240\310K\2638\304n\360G\221\3068\344N\356\261\221\337r\367\217\241\221\032\306\321 \000\000F@\004H\000\000\000\r\022\030na\r>}N\357\371j;6\307\265\334\334&\340\334\233\267\374=\275\231\347\267=\271\347\267<\314\363\333\236\177\"\"\007\310\211\377\304\252DX\261I\314\207\006I\246i\232f\222\366\341\311\210Z\030\3341\016\256\004\303\016 A\271\3036q!\255\003Y\202\2121\021@\025\021UVAddH)\020A\03023S,\331\301(\332U\276\245*m\024\222\275h\257\025\210,i\t\264\214\003\017E*Ey&\005u\302@\242\235\224\370\2459\226HJ(^\220\3304\332m\337\324\261&y\252\204X,\230\225U|@\301\212\016\270^\033\2545\250\314\033@\323h\210.\3512ZR\201\201%jS\251u\237\014\231\263\006\233\000\360\304^f\323f&\310\020\010\026\223\256\331\\\205\205\240\251\373\032\205Z\035\211*\352\225K\322\374c\004q\"\2426#\274p\306\021\n\025\263a\001\215D\203\005sTUk\002\224\225\013\261\002QBj\202\261gG5g;\374\264\261\030\315W\013Nf&\270$\226\371\262\346\223\234\354a\215\362\245\022\214[\230]t\244a~!\204\013\257'9\3665\\\311\320\030\264\300\224\220\360\242B\002\027\242\025a\024\307\317\036\323V\022Z\366\"\023\226\246t\271\275\315\330!P\256\277F\326\3016k\360\251C\216!#c\271}j\3016\233-08\021\357-\230O\013\266Z\325\301\023\017\016\363\362v\271N\010;g>\276\335l\316\306\305\206$U8E\323\264\203E\003'k\212\270\000C\223v,\341\266\230\335\014\362\330\013\324\315\377\221\262\2304\242t#\234\\g:\316\001\027\252<3d\\5E\342\323a\014Hz/8\342\024`'W\001~\026\034\270\201\213\357\303\334\366'?\357\360u\377\306@d\t\222&9'\35446&\250\306(;\320\255~\347-{\234\036\207\303\361y\273-\216\303\330\331\254\2042H\234}\323\221&\0223\362\237\323\204\347/d\376/\021\376\312nlbxx\216\"\347\006\"t\217\027\253\327\005\366\224\273\353\267\265\363\362\346\332Y%G\300\025\010>\307\007q\364\374\256I\344\227\3134\336\314\314\271\340\204\rX\204\245\341\330>A\222FM\0305.$\202\207\272\321BBGKpv\341\3678\3167\342\037\177\326[\266\"g\310\213\023\3108\271\361\335\226FY}\nm\353\035\334\367\242P\322\340\341\341__]\361\010\221LQ8\223\211g\307\363\266\361ga/D$w\363\235u\306 \230\342v`\200=\021\266-L\227(\024A\256\367\273>\365\366\344\355\352\340\344f\030m\361\232{\352lv7\2715j\345\350\337\307\3055\221\031f\341\375{p\023\340P\275\377\273\032\365\r\267\362\254\327\016F\033\234\304U\rW\314\r\275\035B\246\235\024\034\235\363\267\301\360p\031\252\242\265\261|X\361Z\302\232b\324IA \337\210H\307\317\365\253\246\264Fx\001\3205\027\"j111\325K\256\2411&\023\230M\350yzK\207\004(\230e\317\036\224\273\326\254Nx\351\277\300\221\212&\275I\305\340\341z\307\236\3567=4\034`l\320\274\240\330\363\264m`;\255=]C\035\357C&""\030Po\321\025\350\022\230\210\355\324\225m\250KH\355^Q\326<'\343\364\267\2565\357\214\223(\013t\221\330\247\206\352\223\321\203\233e\233\010\202\231\246\226\251\223q\032\005\t\221\242\353\nd _I\250\000\017\006\205\320\202\026\363\035\030B\004KeldA\333zM\276\243\232\356\241\341\235\026s*\344\221`\020p\037;\260\006C0\317N\030I\266\021\005\033\336\306\302\310\220\002\020)s4\035J\3176M\027\350\262\213(\344\373\325=F\2236\250bw\"G\325\3462\377\215\001\227\225\374\267\207\332\201\361\200=\025}\024?7\324\251*\000\320\325\316\373D\027\201\371\035\204\002\302S\\\016\350\232\032ipF\212\363\215\266\026H\025k\000b\252\271p\314`\032\0344\362\237$\264\020\373\205\331\271-\242\3770\003w\372\235\022\010P\201\220\036\370A\257JP\216\353\314\246;\274\254\336f\307\362M&\231g\t \365uq\367\365S\311\254cxr,\266ut\364\326\356\016\0036r\240u\246\315T&[\302\230\014\264u\306\220\324\2640\264\276\360\006\016Yl2F\277%Y<\347\tM\216\361\2276\370\315\251\311\347\244\232F\020c\302\020i\230\267c\010\360]mC\020r\232\r\006\231d\250\032=\365\320n*\342\324\224\024\240\224\207\006\326\266\257\013\035%\343}\333c1\225&yW\273\021\214O\013\n\271tF\206\221*g&ppj\014Il `\356\377u\021|\360|qo|W\034\345.-\024\355B\224\222M\320\220\304\261%\007\201\007\210`\363\356\032\010\003 \0014\351\260\210\013\027\233B!\323\222Ib\t\004\220-2\005c\233 \206\016/3\220\202T\033\030'\266(\213F\265\265\302\250\363J\016\274`\307Nh\206-\223\377\203\006\3437\306+\204q\201\004\261\356\212\234CQ\232\345k\362\336\354\204\212\031b\250\224\236\005\033\365|\260dK\021\010A\030\232\201\n\373%)\262\030\2355\336Qn|\267\031xe\206\016\353\316\202\370X\261\236\2538\2323sPQ\320E +\026\005\3600\315\240\013\205/6n\034\207\341Tb\356\352x9'\331\316\"\232!P\302\026\343\327#_UX\351\352Z\256\335\210\222.\352!\334`i\271\272\335\017\211\220\272\021pppq\244}\330\256=\t\333d\324L\247Q\336r\360\206\000\301\351\363\303\202kP0\025yM\241n\251\361V\007\343\256l\\\335$\242V\204\272qL\230(\014&\000f8\252\212c\243:.i\320\344}U8pP\224v\270t\324-\003\n\2546\362\277""\225\356\230\341\005QT/Z#\300\261N\273t\275\261\246\213\335\217I~V\312\2139IQ\031\265\257_\002\271\353\363\363z\376\021)>\264#\237\304Y-\265\366\362a5\362\206\254\205\360\212\326\r\013\003\306\036 =\353\001\224\240\344fj\267\201\006\267\240\30764\223|\307<+\364\202I\376\320\013\302\370!\020\242\260\344K\261;\362\255\336,\244%\262\030\312 &\364;\326@\037\275\370Fi\020\230\315\345\214\2436\235\367;\257\253\251J5\206\233Z\340F\250F\232u\016\372\003te\343^\335k $C\231\201\001\352E\266\\\236\240\310\215C\276\266\306\274\223M;\005mu\343 6\325\226\240\221y*\201\336\252(\034\344\241\034|]$j\2728K\331v\036\035\036\236\215u\2066,:@4\350\312p]\024\240\033MOm\013\306\204C,t\347\307\211[\232\241\210\311\025\007\256\253\361\312\003 \331\327\337\350\271\227J4\213a,E\372(J\220\201\211(,5l\244llW_\276\247_.\245\023\305Z\014h\300\250\032\202\226~\247\243^k1a\341\301\206\224\315\214\2010=m\313c\355\262\0075a>\234a\304\326E2P\301H+\245\211\203v\r[6XX\223P\343\273\\\320QoB\301\217%\242\247\303\320\335\3446\270\221Kj \345!\021\027L{(\224H|$\251\010X+!\254\006]\262\025\217Mi8Bb\341m\032\254a\276w\254)!\310\306\232\344\014\363\213@P\034g9\240F|\255&9UINx\304'a8\346\\B\302<\320\013J\235\267B\031\214h\330\3125\250m- ,\354\0042,p\301\250\234&\234;\266\224\024\223\031K\327{\340\324u:\200\306\342\261V\312h\003$\255s\206\003\2305\265AX:3'\030\266\021\264\214\335u\207\265\200h\271\326\257\222>m\302\200\340t\342\214\301\276\022\221\006\023\0043\265\313>\221\214N\240$\000HQ\223\267\310\230\343\002GU\021\327*\362\3459\263qWA\014\315r\214#\220\317)X\341\004p\224J^\216\267n\\\335\267\030\215\2500\306\244\024\231U\006\343.&G`+\235)\244^DXSQzLl\021\013\010*\221]\351\274\263\024\314\210\354\022%\202\324\356!ISM\260m\273\356\313k\021l\335r%*\346\226\347]S\021K\2050\314\241V\202\020\315\231#bFs9\234\330\274\307]%%=wtw\362~d\270\214I\034.9\215\347\225\222\237Y\313y\365\300\344mw0\363B\213\341\335\310\004;Wf@\333d\341\030)!\035\035\3618\300\3433\357\307\210\300p2\265\266\261\"mCa\265Q\304\372w%p\256\016s""\253\250\347\305\205\"\370\335\324\224\231\262Q\207\232\004\020\276\343\317,\251\315\260T\335_E\0038\336\243\261G\321\234\213(\213tY\001\005:K#\351\231!\310\364j\002\223\242\"\324\244^\340\274\233n\355\223\371\3328\304\343\234.D\233i8\033r?,\"\362\036}\262\237q(\nP\343I\204\260\317ROp\373FlIxb\376ZC\177\366\007\231{\2119\177\247/\305\247;\320\340\347\245\345e`\300\006EPFTC\004r'\207\372\362\020`M\24561\\*\377\035Y9|\231\275\275\316Q\236L@\260\3147\003\262\256\r\375\324\024M<\244\366\224\315\345q\300\247D\0212\337\254\247\357\230<\034\231\314\310\345.\031#)7\372F\320\267\311\216xo\031{\0319k\326>\303O\034\360d\212\367\270}\355\203\037\267z\030x\230\205\214a\033\022\201na\325\230\305\271\020\2061\2130\230\307y\3461\271\2272\2567s\003\262\330\232\376\002\326\016""\r\253X\005<$t\271x\005\026gP\371%\261/\327\262dK\237+V`\226\347\223\345kKh\361z\233\373\233\265{N\277\316\370\372^\375\253\277N\242\027\n\253\241\334l\021o\372\354\216]\355\313(\211\344L\204;\267f%\347Q\305&\316\271\023T\207$\224\351\222P\263\354^\326|\371%\236/\254K\274;\027Sp\245M9\267aD\344\346\331\253c[\336\225\207\356\332\322}\377_S\255\217\017q\023#\"K\236\305\362\301\377-\243\030\302|\315\200\327\rj\304\234#\001\006\036$d(EU\026d!3`\314\230\013\t\004\027\224`E\234\010>+\311&l\341\300\261\020\"\317./\016\\\335\332\254-\n\236M\010\262\035\253\336-\"\274 \222\270\ni\325\244`\023J\264\227\260p\204Z\022hN\326\2072 \240\254m1A\246X\264\270\252$@\247\020\210x\263\200\034\242D\230.l'\225|\020\313\014\372d\222\305\030\250\213\030\252\257\263\340\330\344\346\307]\327\251gs\237\001\302\327\334\325j\3340\315\004\031\212\377\305\334\221N\024$\017\214\264\261@"; + PyObject *data = __Pyx_DecompressString(cstring, 3853, 2); + if (unlikely(!data)) __PYX_ERR(0, 1, __pyx_L1_error) + const char* const bytes = __Pyx_PyBytes_AsString(data); + #if !CYTHON_ASSUME_SAFE_MACROS + if (likely(bytes)); else { Py_DECREF(data); __PYX_ERR(0, 1, __pyx_L1_error) } + #endif + #elif (CYTHON_COMPRESS_STRINGS) != 0 /* compression: zlib (3846 bytes) */ +const char* const cstring = "x\332\225XK{\323\326\326\256/\024S\\\210\3014@z\212\034\322\004Jpq\260\201rI\217!\t\344\264\004\034\0078\345\246#K\262#\"K\266$;1p\316\3070C\r5\324PC\r=\364\320C\r=\364O\340'|k\355-\337\003O\372<\261\266\264\367^\227\275\326\273.;\267\231\373\265bQ\324\230\272$\3562\202*\352\214\242\032\214\270WQu\221\321\rM\022D\375\001\2470\252\"7\030^\0239Cd8\246@\211\214m\316`$\235\341U\305\220J5\265\2463\222\302\224\305\262\2525\222@\205\2548]\227J\nc\250\014\020\013W\t\037\272\003E\372\233|\306\273\232dp\005Y\3647P\245\212\232Z\376\032\255\244\010\342\036\263+\031\333\214\321\250\210\314\202?oh\234\242\223c\014H\3506\240\2204\2217\030A*\213\212.\251\212\276\322{c~\026\360D\310\200nZ-W\214\006\243os\300\332\250U@\271\242\2521|\303\330V\225$\247i\\c}\222\035\241\327k\225\212\252\031\242\260\256\3249Y\022\230\262*\210\213h[\330,\n\314\002\277\300\000\253\005\340\207\272.,2%\240\352m\246\022\301\234\334\036\350s\36719\303s<\203Zd\036\253u\361RE\022y\361\336\206\n\206#\216x@tB\355\005Q\226\n\242\006&\005\203\241\023A\036\361\226\302<]}z5}+\315p\212\000F}\007\232\350\240h\201\227\301O\340|\340]\250I\262\001r\321\230z\222Y/2\r\265\306(\"h\014N\254\300\276a\002c[T\030]4\360\205Y \226\347\0140\001\013\344\222RZ\360\255(\325E\244^\343d]L>\251\031D\220ZS\004\020\251\364\340\304\361\274\010\334/\221\023?S\010\022\200\010\320U\0275p\264!\226\361[-\240\332\311\345\205\313\213\314\345\313\277s\202\300*h\004<\022\003v\270\266W\220\325\235\232\316\226\032\345_yU\023\177\365\277}\247U\032{\274*\313\250\025\270*\311\025\370\273C\000F.T\347\345\361\351\036n\226\005IG\345D\242b\211g.\241\343J\0042x\02087x\331\020\025\203\304C\037\026\340\032J\"\340Qt\351\275\310\334\275\307\\\233\000\224\242\202\007\213\\M6\030\226\325D\241\306\213,\313\0105b\rEU\256\202G\353\022'\303*/)\222\301\262J\255\\i$Y\361!`\367@\036,D\016-*\302\236\320\000\263C\023$B!\"9T\3244U+J\262\\\224\271\222^\224U\316\200bX&O\354\211X\010:\205g\007\207\364\2176H\227\275t\321\313\225\303\tc\034\253}@\016#s2\237\034\220I&sH?\021Od_\026\355La\310\226\240D\261\330x\016%\033|\205el\014\307\262\263$\t\222\260\307\262\264\024\263l?!\221\026\027\277\261\326O\370\031\360\004\177\267\320\320}\344\365\222\227\237\266h\277\3417\035\262\244\003\2332\007\354\341\271\007\3351jX\226\024\354OaJ\025\300\357,QIA\273\263\376\023\372\030x\212\273\364\201.\301\032B\352\010\250=TO\024t\241\014\222z\306""\352u^\343\232+\025\000B\317n\370J\243\204\274\021N:\351XT\300\217Z,Bt\017y\023dV\240\362\356\020\222\2363)=}\262xN\222\251\311C\350\271\327\377\362U\353\027<*\320w2\234g\324\335\276:\025\265\302\262\320?\322\330\323AO\362\005\033\240\351\242\357\276\347\361\225\300\237\274\325\224\212\304\357\200U\007et|\201\004\375\350\334\252\322\023\320\237\302\02226Er\350AsC\005\341\240eH\321\343\323\203dJW\352\3446\206\t\004\254 S\030\014:\322\211d\334\237@\260jb\t\354\017\001\216\335\0035\220&\0325M\321\010\244u\314{\272(\203W\341\013U\301\007\025\001o~\377;\224\322\331\003\322;i\006\021\322\276\227HX\221- \271\242\033*\374\264\032\\q\320\2168\t\317mM\335\205\023\003rj\025h2\305\232.\366\031\017b\021\336j\364\241\3575\336\213\232\252{\341kn\240\0239\271o\230\367\354\200\035\373\024\350\204/\332){\315Ix\341\031+\325\215\034\353D\317[s\026\327\211\316Xi\253\332\211\376d\tv\242\023\375\301\024,\030\316Yq+\327\211N\233\325n\034\366[\331N\374\222\023v\262N\316\341:\361\177X9\240\214#GX`PBw*n\256\"\221\027\276\342\244>\177\373\315\261+\316\034\354\215\234\265\302V\266\033\211\356?\330\257\231\331N\364$\014\367M\036\266>\263\347\354\202\023r\322N\335\3157\217\265b\255\213\255|;\324Nu\246@.j_\365\302i\027\210\177\031b\325\211\200>\310\377\373\375U\363\214\311\301\316\350\224y\304|f%,\240E^\277\310\356'8J\344\242\235\366\026n7\023M\237\265\257\354\224\0316\327\254Y\340\270e\237\261\005\347g\247\352\206\334L3\324\004Qx\340S\326\022,\235\262\227\354\034\312^2\363\326\221\376\3012\356\021w\253y\256\225h\245[F\373z\033\364Ackv\034vS}2n\256\0339\276\177\307,\001\233\030\010\364\246\320\234?9\272\233p\323\336\315\177\265\023`\017t\244w\232\230\033=9k'\354\033N\314\013\337t\253\335\010\272\352\255\223r\262\310(\r\036\277cq\326G'\325\211\2366Sh\370?\314\252\025\005GQ\211\204f\0264\334v8\247\212\326L[\357\235\363n\312]i\006|C\334i\246\232\331\317\0214\304\2329o\005\254\031\373\276\315;1\264\315I\357\304\005k\317\256:G\0348\304\211\375wp\340\034.DA""x\335\004\320\2342\177\305\243\2342\223v\000\027\346\372,;\30300\314\033\326y8\322\003[\007\177\010\356\274\017\0010\344\017\3466\240q\026\226\252\304\035^\024\021\227\375\224\375\374\035\225S\305\303\245\001\234\300\360_\246\010\000}`\031\366=7\350\002v\301\257\336\217\213\316}g\333-4\303 \225 }\333\346\354*\312\375`\375b\2578ao\361n3\333\004aq/>\017\370@\314Q\337?\266b4tR \360k@\326\314\323\346\n\034\177\213@Lp\022\235\251sV\314\272\010\000HP\213\334!@\317\365\375:\343<\004C\303A\016\347\202\341\367nd\316\376\303\321\334\030\265A\306\374\0260\363\334\246n\036\001-\252\2366\353\326KpR\310I\365OF\035\364\332\216a\234\373D8\367_k\305\016cj@R\335L\000\361{\3734\032\037#\2763u\3012\274\213\000T\227C\314\257\200\031p?,#\234\277\024/y\373\210\235\007\214l\271g\\\276\031\303\340\350\351\024tf\235\025p\325\254\013\311c\3324\254\033\3669'\341,9\233\216\341.\271\233\256\321\274\336\344:g/X\276\3327\314\030\315O\363\336%\342\264n\364\014\002\215JK\014\363\016\003g\014\272x3\337\n\220D\325\211\237\241&\241\206\350b\024\214\331\237\261\203\366\274\023p\342\316\333\346\215\0268\377\222\023@\364_q\256\2006\325\317'\360\204\217\210\250\350\005k\027\200d8\267\3357\020\327)\032s\004\366$\332\350\327\033\373\242\275\345\374\340\220\324\024\205$\003v\333\260\347\274\371[\315\000\330\202\034\372\016\260\371\350\246\335\377\265r-8\354\217`\263\267\316\300\2333\000\331\2427\207\0043\255\373-\016\201\367\247\025@\206',\301\233\205D\346\346\360D\206\265\354\304\020z\t;\356\375\374[3\326D\354\305\316\003\210\211\267\276\305LM\255|\036\262\304\212\033vW\301<[\255\323\255l\347l\002\"\365\3549jA\360\347\231\356\301l\036\2305\313wV\332\252\333/I\032LM\222#I\2348\3435Q\212\3160P_\006L0\216\326 \270\263\004\037y\342\2563M\036\354~v\246\317\035\321\261\322\0146g!\010~\004\000B\276;\007\031\221\242c\251\271\3314Z\327\301l\314\257`c&\201\232UA\221nO\221\263\220\263~\262\017t\266\357\333\303:\364@\253\243\224\017\220\204\357\002`\227!i%H$\370\t\366\262\023\353\366j\313\0019\302\303\364\2151\374=p""\376\316\276L|\022\360\243\326\233^\000\020\0070\003\3124\207L\355\023\020}\017@\276\300t\351\333'<\301\221\023\373[\346y+\355]\270\006.\375\003\014\222\352\204\243\373\017\315\024\234k\021\022Z\370\350\247\372\376\013Z\224;\221Sf\242\023!\370G'\376f?\204\352\024\002\3705ZG[U\334\213\005\327;\231r\343\020\350\245\346\253\366\3216\232ox&\320\227\353\305 /\331\273\220\264\023\207\226\351\315,b\362\033\210\232Gk87\335+\315\027\255lwt&7$\312\007d\334\273\367\244mx\371\222W\332\361vtO\337\375\374\3157{\201\325 \014\253\301u\034\326\203/px\021|\205\303\253\240\214\203\034\254\340P\t~\304\341c\360\237!\030\376\031\332\300a#\264\211\303f\350-\016oC\005\034\n!\031\0079T\301\241\022\252\206\016o\327\337\235\005\222\357@\331\247\336\323\027\336\213\327\336k\326cy\2177<\343\003\312\017dQ\215lp\005\207\225\340#\034\036\365\024.\340P\010\226p(\005\337\341\360.\250\340\240\004k8\324z\247\310\242n\331\320\n\016+\241G8<\n\345q\310\207^\342\3602\304\342\300\366\316T\304\241\030RqPCu\034\352\241\335\320\300\035W\240\017\253\272G\335\017\255\205v\254;:\223\030 n\232\000\373\320\006\271aO\223 \017\273\353\350\346\277\357\3759\250\325\307\001\247\357[\361\326[/\017&}\343\275\341<\256\3607\200w\325y\0019\357ts\245u\254=\355=\315\r\264X\304\330s\247\233\307[7\333\211\356\350LjL\213\223\220y~o\317\265\025\357\365\177\274\377p\207\267\301\2623\rI.\017\255\310F{\301\313=\367\236\377\345\375\005\247x\347\275\253z\325\272Wox\215\377\202?\376\027XC\347\256\005\037\343\3608\270\021\034(z\031\212S\316)\271\2570\\\273\2433\303q\211\211n\007\"\026+`\356\260*\016\305\377\317P\267b\000\342\231\346C\314\205#3\244\367\204\354\346\314\273\001\013\272O\310\244\243\2754\346\316\245\375.genexpr__class____class_getitem__clearcline_in_tracebackclosecopycorner_rulecornerscountcoveragecurrent_playercxcy__dict__dict_dictdtypedtype_is_objectdxdyencodeenumerateerrorfillflagsfloatformatfortran__func__game_overgenexprget_actionget_cellget_moveget_occupiedget_orientationsget_pieceget_piece_idget_player_cornersget_player_occupiedget_player_squaresget_stateget_valid_actions__getstate__grid_viewhas_overlaphas_startedhas_valid_movesiididx__import__in_boundsindex__init__..genexprintint8_is_coroutineis_emptyis_fullitemsitemsizelist__main__maxmemviewminmode__module__movename__name__ndim__new__new_gamenextnext_idxnext_playernormalize_squares_cython..genexprnpnum_actionsnum_piecesnum_playersnumpyoobjoffsetorientation_idppackpiecepiece_idpiecespieces_listplaceplaced_cornersplaced_squaresplay_moveplayerplayer_idxplayer_squaresplayerspop__pyx_checksum__pyx_result__pyx_state__pyx_type__pyx_unpickle_BlokusGame__pyx_unpickle_Board__pyx_unpickle_Enum__pyx_unpickle_Move__pyx_unpickle_Piece__pyx_unpickle_PieceOrientation__pyx_unpickle_PieceSet__pyx_unpickle_PlayerState__pyx_vtable____qualname____reduce____reduce_cython____reduce_ex__registerresetresultreturnroundsscoreselfsendset__set_name__setdefault__setstate____setstate_cython__shapesizesquaresstartstatestepstopstructsum__test__throwunpackupdateuse_setstatevalid_movevaluevaluesxyzeros\320\0040\260\001\330\010\017\210t\220=\240\001\240\021\200\001\330\004#\2401\240F\250!\320\004\033\2301\340\010\t""\330\014\032\230$\230a\330\014\033\2304\230q\330\014\036\230d\240!\330\014\026\220d\230!\330\014\031\230\024\230Q\330\014\027\220q\340\024\033\2301\230A\330\024(\250\004\250A\250Q\250a\330\024\035\230Q\230a\330\024#\2401\240A\330\024 \240\001\240\021\340\020\024\220E\230\024\230Q\320\004+\2501\360\006\000\t+\250$\250a\330\010\030\230\004\230A\340\010\014\210C\210u\220A\330\014\017\210u\220B\220c\230\024\230U\240$\240b\250\003\2504\250v\260S\270\t\300\021\300#\300S\310\003\3101\330\020\027\220q\330\010\017\210q\320\0044\260A\340\010*\250$\250a\330\010\030\230\004\230A\330\010\033\2301\360\006\000\t\r\210E\220\025\220a\220q\330\014\020\220\005\220U\230!\2301\330\020\023\2209\230A\230S\240\003\2403\240a\330\024\032\230'\240\022\2403\240a\330\010\017\210q\320\0044\260A\340\010*\250$\250a\330\010\030\230\004\230A\330\010\036\230a\330\010#\2404\320':\270!\2701\360\006\000\t\r\210C\210u\220A\330\014\020\220\004\220F\230\"\230A\230T\240\025\240d\250%\250q\260\003\2605\270\003\2701\330\020\024\220E\230\022\2302\230T\240\022\2402\240Q\330\020\023\2202\220S\230\005\230U\240$\240b\250\003\2505\260\005\260T\270\031\300!\3004\300t\3103\310a\330\024\033\2304\230r\240\024\240Q\330\010\017\210q\320\0045\260Q\340\010\013\210;\220g\230T\240\021\330\014\020\320\020 \240\001\240\036\250s\260!\2604\3207J\310!\3101\330\010\017\210t\320\023#\2401\240A\200\001\330\004\"\240!\2406\250\021\320\0047\260q\340\010\031\230\024\230^\2501\250A\340\010\013\2104\210t\220;\230a\230|\2501\330\014\023\2201\340\010\014\210K\220q\230\014\240A\330\010\017\210q\320\0047\260q\340\010\"\240$\240h\250a\250q\330\010\033\2304\230z\250\032\2601\260D\270\001\330\010#\2404\320';\2701\270A\360\010\000\t\r\210F\220&\230\001\230\033\240B\240c\250\021\360\006\000\t\017\320\016\037\230x\240q\250\005\250Q\330\010\016\210j\230\005\230Q\360\006\000\t\014\2104\210v\220Q\330\014\022\220/\240\021\330\014\022\220.\240\001\360\006\000\t$\2404\320';\2701\270A\330\010\014\210C\210u\220A\330\014\017\210t\2206\230\032\2401\240C""\240s\250$\250d\260&\270\t\300\021\300#\300Q\330\020\026\220h\230d\240\"\240C\240q\360\006\000\t\r\320\014\035\230Q\230A\200A\360\n\000\t\014\2104\210q\330\014\023\2204\220q\340\010\014\210J\220e\2301\230C\230t\240=\260\002\260!\330\014\030\230\004\320\034,\250B\250h\260b\270\004\270A\330\014\032\230$\230h\240a\240q\330\014\017\210{\230*\240D\250\004\320,<\270A\270Q\330\020\024\320\024&\240a\330\020\027\220q\360\006\000\t\r\210M\230\021\330\010\017\210t\2201\200A\360\006\000\t+\250$\250a\330\010\030\230\004\230A\340\010\014\210C\210u\220A\330\014\017\210r\220\023\220D\230\005\230T\240\022\2403\240d\250!\330\020\031\230\021\230#\230U\240!\360\006\000\t\014\210;\220c\230\024\230Q\330\014\020\320\020 \240\001\240\033\250G\2601\260A\200A\340\010\"\240$\240h\250a\250q\330\010\033\2304\230z\250\032\2601\260D\270\001\330\010#\2404\320';\2701\270A\330\010#\2404\320';\2701\270A\340\010$\240K\250r\260\021\360\n\000\t\014\2105\220\006\220g\230V\2401\330\014\023\2201\360\006\000\t\r\210C\210u\220A\330\014\017\210t\2204\220v\230Z\240q\250\003\2501\330\020\027\220q\360\006\000\t\014\2104\210v\220\\\240\021\240!\330\014\023\2201\360\006\000\t\014\2104\210}\230D\240\004\240F\250!\330\014\017\210s\220!\2204\220z\240\023\240C\240q\250\004\250A\330\020\037\230t\320#5\260Q\260a\330\020\024\220D\230\004\230D\240\004\240C\240q\330\024\033\2301\360\006\000\t\r\210C\210u\220A\330\014\020\220\004\220F\230\"\230A\230S\240\005\240S\250\005\250T\260\025\260c\270\021\330\020\023\2204\220v\230Z\240q\250\002\250\"\250D\260\002\260\"\260A\330\024\027\220t\2306\240\031\250!\2502\250R\250t\2602\260R\260t\2703\270a\330\030\037\230q\360\006\000\t\014\2106\220\021\330\014\036\230d\240&\320(<\270A\270Q\340\014\025\220Q\330\014\020\220\004\220F\230!\330\020\023\2204\220v\230Z\240q\250\004\250D\260\005\260T\270\024\270S\300\001\330\024\035\230Q\330\024\025\330\014\017\210t\2201\330\020\027\220q\340\010\017\210q\200A\340\010\"\240$\240h\250a\250q\330\010 \240\002\240&\250\001\250\024\250^\2706\300\021\330""\010(\250\001\360\010\000\t+\250+\260R\260q\360\016\000\t\r\210H\220F\230!\330\014\037\230w\240a\240t\250:\260]\300!\3001\340\010\013\2104\210v\220Q\330\014\023\2201\340\010\013\2104\210v\220]\240#\240T\250\026\250q\330\014\020\220\014\230A\330\020\024\220N\240$\320&8\270\001\270\021\330\024\027\220t\230;\240a\240|\2604\260~\300Q\300a\330\030\034\230A\230^\2501\330\014\023\2201\360\006\000\t\033\230$\230f\320$8\270\001\270\033\300B\300a\340\010\014\210L\230\001\330\014\020\220\016\230d\320\"4\260A\260Q\330\020\027\220t\230>\250\021\250!\330\020!\240\024\320%9\270\021\270!\360\006\000\021\032\230\021\330\020\024\220D\230\006\230a\330\024\027\220t\2306\240\032\2501\250D\260\004\260E\270\024\270T\300\023\300A\330\030!\240\021\330\030\031\330\020\023\2204\220q\330\024\025\340\020!\240\024\320%9\270\021\270!\360\006\000\021\032\230\021\330\020\024\220C\220u\230A\330\024\027\220t\2304\230v\240Z\250q\260\003\2601\330\030!\240\021\330\030\031\330\020\023\2204\220q\330\024\025\360\006\000\021\024\2204\220v\230\\\250\021\250!\330\024\025\360\006\000\021 \230q\330\020\024\220C\220u\230A\330\024\030\230\004\230F\240\"\240A\240S\250\005\250S\260\005\260T\270\025\270c\300\021\330\030\033\2304\230v\240Z\250q\260\002\260\"\260D\270\002\270\"\270A\330\034\037\230t\2406\250\031\260!\2602\260R\260t\2702\270R\270t\3003\300a\330 /\250q\330 !\330\024\027\220q\330\030\031\340\020\023\2204\220q\330\024\030\230\001\230\036\240q\340\010\017\210q\200A\340\010\"\240$\240h\250a\250q\330\010(\250\001\360\010\000\t\r\210H\220F\230!\330\014\037\230w\240a\240t\250:\260]\300!\3001\340\010\013\2104\210v\220Q\330\014\023\2201\340\010\014\210L\230\001\330\014\020\220\016\230d\320\"4\260A\260Q\330\020\023\2204\220{\240!\240<\250t\260>\300\021\300!\330\024\033\2301\330\010\017\210q\320\004)\250\021\340\010\030\230\004\230A\330\010\017\210r\220\023\220D\230\005\230T\240\022\2403\240d\250!\320\004\"\240!\360\n\000\t\r\210L\230\n\240)\2501\250D\260\001\330\014\017\210t\2204\320\027'\240q\250\001\330\020""\026\220l\240!\360\006\000\t\020\210q\330\014\020\220\r\230Q\330\037 \340\014\020\220\r\230Q\200\001\360\010\000\005\016\210T\220\032\2304\320\0370\260\004\260K\270t\3001\330\004\014\210G\2201\220F\230,\240a\330\004\007\200v\210W\220E\230\024\230Q\330\010\022\220!\330\010\027\220q\340\010\027\220t\2309\240G\2505\260\003\2604\260y\300\007\300q\330\004\007\200q\330\010\017\320\0171\260\024\260Q\260g\270[\310\007\310q\340\010\017\320\0171\260\024\260Q\260g\270[\310\001\200\001\360\010\000\005\016\210T\320\021#\2404\240w\250d\260!\330\004\014\210G\2201\220F\230,\240a\330\004\007\200v\210W\220E\230\024\230Q\330\010\022\220!\330\010\027\220q\340\010\027\220t\320\033,\250G\2601\330\004\007\200q\330\010\017\320\017&\240d\250!\2507\260+\270W\300A\340\010\017\320\017&\240d\250!\2507\260+\270Q\200\001\360\010\000\005\016\210T\320\021!\240\024\320%9\270\024\320=O\310t\320Sg\320gk\320ks\320sw\360\000\000x\001E\002\360\000\000E\002I\002\360\000\000I\002W\002\360\000\000W\002[\002\360\000\000[\002l\002\360\000\000l\002p\002\360\000\000p\002|\002\360\000\000|\002@\003\360\000\000@\003N\003\360\000\000N\003R\003\360\000\000R\003^\003\360\000\000^\003b\003\360\000\000b\003l\003\360\000\000l\003p\003\360\000\000p\003q\003\330\004\014\210G\2201\220F\230,\240a\330\004\007\200v\210W\220E\230\024\230Q\330\010\022\220!\330\010\027\220q\340\010\027\220t\230?\250'\260\025\260c\270\024\320=P\320PW\320W\\\320\\_\320_c\320ct\320t{\360\000\000|\001A\002\360\000\000A\002D\002\360\000\000D\002H\002\360\000\000H\002[\002\360\000\000[\002b\002\360\000\000b\002g\002\360\000\000g\002j\002\360\000\000j\002n\002\360\000\000n\002u\002\360\000\000u\002|\002\360\000\000|\002A\003\360\000\000A\003D\003\360\000\000D\003H\003\360\000\000H\003S\003\360\000\000S\003Z\003\360\000\000Z\003_\003\360\000\000_\003b\003\360\000\000b\003f\003\360\000\000f\003o\003\360\000\000o\003v\003\360\000\000v\003w\003\330\004\007\200q\330\010\017\320\017+\2504\250q\260\007\260{\300'\310\021\340\010\017\320\017+\2504\250q\260""\007\260{\300!\200\001\360\010\000\005\016\210T\220\027\230\004\230A\330\004\014\210G\2201\220F\230,\240a\330\004\007\200v\210W\220E\230\024\230Q\330\010\022\220!\330\010\027\220q\340\010\027\220t\2306\240\027\250\005\250S\260\004\260I\270W\300A\330\004\007\200q\330\010\017\320\017&\240d\250!\2507\260+\270W\300A\340\010\017\320\017&\240d\250!\2507\260+\270Q\200\001\360\010\000\005\016\210T\320\021$\240D\250\013\2604\260z\300\024\300^\320SW\320W]\320]a\320ab\330\004\014\210G\2201\220F\230,\240a\330\004\007\200v\210W\220E\230\024\230Q\330\010\022\220!\330\010\027\220q\340\010\027\220t\320\033-\250W\260E\270\023\270D\300\t\310\027\320PQ\330\004\007\200q\330\010\017\320\017,\250D\260\001\260\027\270\013\3007\310!\340\010\017\320\017,\250D\260\001\260\027\270\013\3001\200\001\360\010\000\005\016\210T\320\021$\240D\250\017\260t\270?\310$\310n\320\\`\320`a\330\004\014\210G\2201\220F\230,\240a\330\004\007\200v\210W\220E\230\024\230Q\330\010\022\220!\330\010\027\220q\340\010\027\220t\230>\250\027\260\005\260S\270\004\270N\310'\320QV\320VY\320Y]\320]j\320jq\320qv\320vy\320y}\360\000\000~\001F\002\360\000\000F\002M\002\360\000\000M\002N\002\330\004\007\200q\330\010\017\320\017)\250\024\250Q\250g\260[\300\007\300q\340\010\017\320\017)\250\024\250Q\250g\260[\300\001\200\001\360\010\000\005\016\210T\320\021\"\240$\240k\260\024\260T\270\024\270Q\330\004\014\210G\2201\220F\230,\240a\330\004\007\200v\210W\220E\230\024\230Q\330\010\022\220!\330\010\027\220q\340\010\027\220q\330\004\007\200q\330\010\017\320\017%\240T\250\021\250'\260\033\270G\3001\340\010\017\320\017%\240T\250\021\250'\260\033\270A\200\001\330\004)\250\021\250&\260\001\230\021\320\004(\250\001\340\010*\250$\250a\330\010\030\230\004\230A\340\010\013\2102\210S\220\004\220E\230\024\230R\230s\240$\240a\330\014\023\2209\230A\230S\240\003\2403\240a\330\010\017\210q\320\004(\250\001\340\010*\250$\250a\330\010\030\230\004\230A\340\010\013\2102\210S\220\004\220E\230\024\230R\230s\240$\240a\330\014\023\2209\230A\230S\240\001""\330\010\017\210q\320\004\031\230\021\340\010*\250$\250a\330\010\030\230\004\230A\360\006\000\t\r\210E\220\025\220a\220q\330\014\020\220\005\220U\230!\2301\330\020\023\2209\230A\230S\240\003\2403\240a\330\024\033\2301\330\010\017\210q\320\004\032\230!\340\010*\250$\250a\330\010\030\230\004\230A\330\010\031\230\021\360\006\000\t\r\210E\220\025\220a\220q\330\014\020\220\005\220U\230!\2301\330\020\023\2209\230A\230S\240\003\2403\240a\330\024\035\230Q\330\010\017\210v\220S\230\005\230R\230q\320\004\026\220a\340\010#\240:\250Q\330\014\027\220t\2301\330\014\023\2204\220q\330\014\030\230\004\230A\330\014\030\230\004\230A\360\006\000\t\021\220\t\230\024\230V\2405\250\001\330\010\020\320\020\"\240$\240a\330\010\020\220\n\230$\230a\330\010\020\220\r\230T\240\021\340\010\014\210C\210u\220I\230Q\230d\240!\330\014\024\220H\230A\230R\320\0373\2601\3204E\300U\310!\330\014\024\220H\230A\230R\230{\250!\2508\2605\270\001\330\014\024\220H\230A\230R\230y\250\001\250\021\330\014\024\220H\230A\230R\230\177\250a\250q\330\014\024\220H\230A\230R\230|\2501\250A\340\010\017\210q\320\004\036\230a\340\010*\250$\250a\330\010\030\230\004\230A\330\010\035\230Q\360\006\000\t\r\210E\220\025\220a\220q\330\014\020\220\005\220U\230!\2301\330\020\023\2209\230A\230S\240\003\2403\240a\330\024\032\230$\230b\240\003\2401\330\010\017\210q\320\004&\240a\330\010\017\210t\220>\240\021\240!\200\001\330\004.\250a\250v\260Q\200\001\330\004&\240a\240v\250Q\240q\200\001\340\004\037\230q\320 0\260\013\270;\300k\320QR\330\004\023\2204\220x\230q\240\001\330\004\007\200|\2207\230!\330\010&\240a\240w\250n\270A\330\004\013\2101\200\001\340\004\037\230q\320 0\260\013\270;\300k\320QR\330\004\023\2205\230\010\240\001\240\021\330\004\007\200|\2207\230!\330\010'\240q\250\010\260\016\270a\330\004\013\2101\200\001\340\004\037\230q\320 0\260\013\270;\300k\320QR\330\004\023\320\023#\2408\2501\250A\330\004\007\200|\2207\230!\330\0102\260!\3203F\300n\320TU\330\004\013\2101\200\001\340\004\037\230q\320 0\260\013\270;\300k\320QR\330""\004\023\2208\2308\2401\240A\330\004\007\200|\2207\230!\330\010*\250!\250;\260n\300A\330\004\013\2101\200\001\340\004\037\230q\320 0\260\013\270;\300k\320QR\330\004\023\220:\230X\240Q\240a\330\004\007\200|\2207\230!\330\010,\250A\250]\270.\310\001\330\004\013\2101\200\001\340\004\037\230q\320 0\260\013\270;\300k\320QR\330\004\023\220;\230h\240a\240q\330\004\007\200|\2207\230!\330\010-\250Q\250n\270N\310!\330\004\013\2101\210q\230q\200\001\330\004(\250\001\250\026\250q\320\004\027\220q\340\010\014\210E\220\025\220a\220q\320\004\027\220q\340\010\014\210I\220U\230!\2304\230q\330\010\014\210K\220q\330\010\014\320\014\036\230a\330\010\014\210J\220a\330\010\014\210M\230\021\340\010\014\210E\220\025\220a\220t\2301\330\014\025\220[\240\001\330\014\022\220'\230\021\330\014\022\320\022&\240c\250\021\250$\250j\270\001\330\014\017\210t\220=\240\004\240B\240b\250\003\2501\250D\260\001\330\020\026\220l\240$\320&8\270\001\270\021\340\020\026\220n\240A\330\014\022\220)\2301\330\014\022\220/\240\021\330\014\022\220,\230a\330\014\020\220\010\230\007\230q\240\001\320\004'\240q\330\010\017\210t\320\023#\2402\240T\250\033\260D\3208I\310\024\310T\320QU\320UV\320\004(\250\001\330\010\017\210t\220=\240\001\240\021\320\004)\250\021\330\010\017\210t\2207\230!\2301O"; + PyObject *data = NULL; + CYTHON_UNUSED_VAR(__Pyx_DecompressString); + #endif + PyObject **stringtab = __pyx_mstate->__pyx_string_tab; + Py_ssize_t pos = 0; + for (int i = 0; i < 296; i++) { + Py_ssize_t bytes_length = index[i].length; + PyObject *string = PyUnicode_DecodeUTF8(bytes + pos, bytes_length, NULL); + if (likely(string) && i >= 50) PyUnicode_InternInPlace(&string); + if (unlikely(!string)) { + Py_XDECREF(data); + __PYX_ERR(0, 1, __pyx_L1_error) + } + stringtab[i] = string; + pos += bytes_length; + } + for (int i = 296; i < 348; i++) { + Py_ssize_t bytes_length = index[i].length; + PyObject *string = PyBytes_FromStringAndSize(bytes + pos, bytes_length); + stringtab[i] = string; + pos += bytes_length; + if (unlikely(!string)) { + Py_XDECREF(data); + __PYX_ERR(0, 1, __pyx_L1_error) + } + } + Py_XDECREF(data); + for (Py_ssize_t i = 0; i < 348; i++) { + if (unlikely(PyObject_Hash(stringtab[i]) == -1)) { + __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #if CYTHON_IMMORTAL_CONSTANTS + { + PyObject **table = stringtab + 296; + for (Py_ssize_t i=0; i<52; ++i) { + #if PY_VERSION_HEX >= 0x030F0000 + PyUnstable_SetImmortal(table[i]); + #elif CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if ((PY_SSIZE_T_MAX <= _Py_IMMORTAL_REFCNT_LOCAL)) break; + #if PY_VERSION_HEX < 0x030E0000 + if (_Py_IsOwnedByCurrentThread(table[i]) && Py_REFCNT(table[i]) == 1) + #else + if (PyUnstable_Object_IsUniquelyReferenced(table[i])) + #endif + { + Py_SET_REFCNT(table[i], ((Py_ssize_t)_Py_IMMORTAL_REFCNT_LOCAL + 1)); + } + #else + if ((PY_SSIZE_T_MAX < _Py_IMMORTAL_INITIAL_REFCNT)) break; + Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); + #endif + } + } + #endif + } + { + PyObject **numbertab = __pyx_mstate->__pyx_number_tab + 0; + int8_t const cint_constants_1[] = {0,-1,1,2,3,4}; + int32_t const cint_constants_4[] = {5311788L,10809183L,48998121L,72639080L,136365258L,136983863L,189654061L,260500659L}; + for (int i = 0; i < 14; i++) { + numbertab[i] = PyLong_FromLong((i < 6 ? cint_constants_1[i - 0] : cint_constants_4[i - 6])); + if (unlikely(!numbertab[i])) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #if CYTHON_IMMORTAL_CONSTANTS + { + PyObject **table = __pyx_mstate->__pyx_number_tab; + for (Py_ssize_t i=0; i<14; ++i) { + #if PY_VERSION_HEX >= 0x030F0000 + PyUnstable_SetImmortal(table[i]); + #elif CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if ((PY_SSIZE_T_MAX <= _Py_IMMORTAL_REFCNT_LOCAL)) break; + #if PY_VERSION_HEX < 0x030E0000 + if (_Py_IsOwnedByCurrentThread(table[i]) && Py_REFCNT(table[i]) == 1) + #else + if (PyUnstable_Object_IsUniquelyReferenced(table[i])) + #endif + { + Py_SET_REFCNT(table[i], ((Py_ssize_t)_Py_IMMORTAL_REFCNT_LOCAL + 1)); + } + #else + if ((PY_SSIZE_T_MAX < _Py_IMMORTAL_INITIAL_REFCNT)) break; + Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); + #endif + } + } + #endif + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: init_codeobjects ### */ +typedef struct { + unsigned int argcount : 2; + unsigned int num_posonly_args : 1; + unsigned int num_kwonly_args : 1; + unsigned int nlocals : 4; + unsigned int flags : 10; + unsigned int first_line : 10; +} __Pyx_PyCode_New_function_description; +/* NewCodeObj.proto */ +static PyObject* __Pyx_PyCode_New( + const __Pyx_PyCode_New_function_description descr, + PyObject * const *varnames, + PyObject *filename, + PyObject *funcname, + PyObject *line_table, + PyObject *tuple_dedup_map +); + + +static int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate) { + PyObject* tuple_dedup_map = PyDict_New(); + if (unlikely(!tuple_dedup_map)) return -1; + { + const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_GENERATOR), 241}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_o}; + __pyx_mstate_global->__pyx_codeobj_tab[0] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_genexpr, __pyx_mstate->__pyx_kp_b_iso88591_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[0])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_GENERATOR), 351}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_x, __pyx_mstate->__pyx_n_u__10}; + __pyx_mstate_global->__pyx_codeobj_tab[1] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_genexpr, __pyx_mstate->__pyx_kp_b_iso88591__9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[1])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_GENERATOR), 352}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u__10, __pyx_mstate->__pyx_n_u_y}; + __pyx_mstate_global->__pyx_codeobj_tab[2] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_genexpr, __pyx_mstate->__pyx_kp_b_iso88591__9, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[2])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_GENERATOR), 481}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_x, __pyx_mstate->__pyx_n_u__10}; + __pyx_mstate_global->__pyx_codeobj_tab[3] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_genexpr, __pyx_mstate->__pyx_kp_b_iso88591_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[3])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_GENERATOR), 482}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u__10, __pyx_mstate->__pyx_n_u_y}; + __pyx_mstate_global->__pyx_codeobj_tab[4] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_genexpr, __pyx_mstate->__pyx_kp_b_iso88591_A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[4])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_GENERATOR), 754}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_p}; + __pyx_mstate_global->__pyx_codeobj_tab[5] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_genexpr, __pyx_mstate->__pyx_kp_b_iso88591_q_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[5])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {0, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_GENERATOR), 756}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_p}; + __pyx_mstate_global->__pyx_codeobj_tab[6] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_genexpr, __pyx_mstate->__pyx_kp_b_iso88591_q_3, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[6])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 35}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_player_idx, __pyx_mstate->__pyx_n_u_squares, __pyx_mstate->__pyx_n_u_x, __pyx_mstate->__pyx_n_u_y, __pyx_mstate->__pyx_n_u_grid_view, __pyx_mstate->__pyx_n_u_size}; + __pyx_mstate_global->__pyx_codeobj_tab[7] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_place, __pyx_mstate->__pyx_kp_b_iso88591_A_a_A_CuA_r_D_T_3d_U_c_Q_G1A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[7])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 1, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 49}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self}; + __pyx_mstate_global->__pyx_codeobj_tab[8] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_clear, __pyx_mstate->__pyx_kp_b_iso88591_q_E_aq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[8])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 53}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_x, __pyx_mstate->__pyx_n_u_y, __pyx_mstate->__pyx_n_u_grid_view, __pyx_mstate->__pyx_n_u_size}; + __pyx_mstate_global->__pyx_codeobj_tab[9] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_is_empty, __pyx_mstate->__pyx_kp_b_iso88591_a_A_2S_E_Rs_a_9AS_3a_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[9])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 62}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_x, __pyx_mstate->__pyx_n_u_y, __pyx_mstate->__pyx_n_u_size}; + __pyx_mstate_global->__pyx_codeobj_tab[10] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_in_bounds, __pyx_mstate->__pyx_kp_b_iso88591_A_r_D_T_3d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[10])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 6, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 67}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_squares, __pyx_mstate->__pyx_n_u_x, __pyx_mstate->__pyx_n_u_y, __pyx_mstate->__pyx_n_u_grid_view, __pyx_mstate->__pyx_n_u_size}; + __pyx_mstate_global->__pyx_codeobj_tab[11] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_has_overlap, __pyx_mstate->__pyx_kp_b_iso88591_1_a_A_CuA_uBc_U_b_4vS_S_1_q_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[11])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 85}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_x, __pyx_mstate->__pyx_n_u_y, __pyx_mstate->__pyx_n_u_grid_view, __pyx_mstate->__pyx_n_u_size}; + __pyx_mstate_global->__pyx_codeobj_tab[12] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_get_cell, __pyx_mstate->__pyx_kp_b_iso88591_a_A_2S_E_Rs_a_9AS_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[12])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 7, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 94}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_player_idx, __pyx_mstate->__pyx_n_u_grid_view, __pyx_mstate->__pyx_n_u_size, __pyx_mstate->__pyx_n_u_result, __pyx_mstate->__pyx_n_u_x, __pyx_mstate->__pyx_n_u_y}; + __pyx_mstate_global->__pyx_codeobj_tab[13] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_get_player_squares, __pyx_mstate->__pyx_kp_b_iso88591_4A_a_A_1_E_aq_U_1_9AS_3a_3a_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[13])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 107}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_player_idx}; + __pyx_mstate_global->__pyx_codeobj_tab[14] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_get_player_occupied, __pyx_mstate->__pyx_kp_b_iso88591_5Q_gT_s_47J_1_t_1A, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[14])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 12, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 113}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_player_idx, __pyx_mstate->__pyx_n_u_grid_view, __pyx_mstate->__pyx_n_u_size, __pyx_mstate->__pyx_n_u_corners, __pyx_mstate->__pyx_n_u_player_squares, __pyx_mstate->__pyx_n_u_x, __pyx_mstate->__pyx_n_u_y, __pyx_mstate->__pyx_n_u_dx, __pyx_mstate->__pyx_n_u_dy, __pyx_mstate->__pyx_n_u_cx, __pyx_mstate->__pyx_n_u_cy}; + __pyx_mstate_global->__pyx_codeobj_tab[15] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_get_player_corners, __pyx_mstate->__pyx_kp_b_iso88591_4A_a_A_a_4_1_CuA_F_AT_d_q_5_1_E, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[15])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 6, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 128}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_grid_view, __pyx_mstate->__pyx_n_u_size, __pyx_mstate->__pyx_n_u_result, __pyx_mstate->__pyx_n_u_x, __pyx_mstate->__pyx_n_u_y}; + __pyx_mstate_global->__pyx_codeobj_tab[16] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_get_occupied, __pyx_mstate->__pyx_kp_b_iso88591_a_a_A_Q_E_aq_U_1_9AS_3a_b_1_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[16])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 5, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 141}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_grid_view, __pyx_mstate->__pyx_n_u_size, __pyx_mstate->__pyx_n_u_x, __pyx_mstate->__pyx_n_u_y}; + __pyx_mstate_global->__pyx_codeobj_tab[17] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_is_full, __pyx_mstate->__pyx_kp_b_iso88591_a_A_E_aq_U_1_9AS_3a_1_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[17])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 6, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 153}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_grid_view, __pyx_mstate->__pyx_n_u_size, __pyx_mstate->__pyx_n_u_count, __pyx_mstate->__pyx_n_u_x, __pyx_mstate->__pyx_n_u_y}; + __pyx_mstate_global->__pyx_codeobj_tab[18] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_coverage, __pyx_mstate->__pyx_kp_b_iso88591_a_A_E_aq_U_1_9AS_3a_Q_vS_Rq, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[18])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_state, __pyx_mstate->__pyx_n_u_dict_3, __pyx_mstate->__pyx_n_u_use_setstate}; + __pyx_mstate_global->__pyx_codeobj_tab[19] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_mstate->__pyx_kp_b_iso88591_T_4wd_G1F_a_vWE_Q_q_t_G1_q_d_7, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[19])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 16}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state}; + __pyx_mstate_global->__pyx_codeobj_tab[20] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_mstate->__pyx_kp_b_iso88591_1F, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[20])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_state, __pyx_mstate->__pyx_n_u_dict_3, __pyx_mstate->__pyx_n_u_use_setstate}; + __pyx_mstate_global->__pyx_codeobj_tab[21] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_mstate->__pyx_kp_b_iso88591_T_k_T_Q_G1F_a_vWE_Q_q_q_q_T_G1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[21])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 16}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state}; + __pyx_mstate_global->__pyx_codeobj_tab[22] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_mstate->__pyx_kp_b_iso88591_6, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[22])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_state, __pyx_mstate->__pyx_n_u_dict_3, __pyx_mstate->__pyx_n_u_use_setstate}; + __pyx_mstate_global->__pyx_codeobj_tab[23] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_mstate->__pyx_kp_b_iso88591_T_4_0_Kt1_G1F_a_vWE_Q_q_t9G5_4y, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[23])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 16}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state}; + __pyx_mstate_global->__pyx_codeobj_tab[24] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_mstate->__pyx_kp_b_iso88591_avQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[24])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_state, __pyx_mstate->__pyx_n_u_dict_3, __pyx_mstate->__pyx_n_u_use_setstate}; + __pyx_mstate_global->__pyx_codeobj_tab[25] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_mstate->__pyx_kp_b_iso88591_T_A_G1F_a_vWE_Q_q_t6_S_IWA_q_d, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[25])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 16}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state}; + __pyx_mstate_global->__pyx_codeobj_tab[26] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_mstate->__pyx_kp_b_iso88591_1F, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[26])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 247}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_piece_id}; + __pyx_mstate_global->__pyx_codeobj_tab[27] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_get_orientations, __pyx_mstate->__pyx_kp_b_iso88591_0_t, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[27])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 250}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_piece_id}; + __pyx_mstate_global->__pyx_codeobj_tab[28] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_get_piece, __pyx_mstate->__pyx_kp_b_iso88591_t7_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[28])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 253}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_name}; + __pyx_mstate_global->__pyx_codeobj_tab[29] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_get_piece_id, __pyx_mstate->__pyx_kp_b_iso88591_t, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[29])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_state, __pyx_mstate->__pyx_n_u_dict_3, __pyx_mstate->__pyx_n_u_use_setstate}; + __pyx_mstate_global->__pyx_codeobj_tab[30] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_mstate->__pyx_kp_b_iso88591_T_D_t_n_a_G1F_a_vWE_Q_q_t_S_N_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[30])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 16}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state}; + __pyx_mstate_global->__pyx_codeobj_tab[31] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_mstate->__pyx_kp_b_iso88591_avQ_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[31])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_state, __pyx_mstate->__pyx_n_u_dict_3, __pyx_mstate->__pyx_n_u_use_setstate}; + __pyx_mstate_global->__pyx_codeobj_tab[32] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_mstate->__pyx_kp_b_iso88591_T_D_4z_SWW_aab_G1F_a_vWE_Q_q_t, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[32])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 16}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state}; + __pyx_mstate_global->__pyx_codeobj_tab[33] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_mstate->__pyx_kp_b_iso88591__11, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[33])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 495}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_action}; + __pyx_mstate_global->__pyx_codeobj_tab[34] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_get_move, __pyx_mstate->__pyx_kp_b_iso88591_a_t, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[34])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 498}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_move}; + __pyx_mstate_global->__pyx_codeobj_tab[35] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_get_action, __pyx_mstate->__pyx_kp_b_iso88591_q_t_2T_D8I_TQUUV, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[35])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 501}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_player}; + __pyx_mstate_global->__pyx_codeobj_tab[36] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_reset, __pyx_mstate->__pyx_kp_b_iso88591_q_IU_4q_Kq_a_Ja_M_E_at1_c_j_t_B, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[36])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 3, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 540}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_player_idx, __pyx_mstate->__pyx_n_u_move}; + __pyx_mstate_global->__pyx_codeobj_tab[37] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_valid_move, __pyx_mstate->__pyx_kp_b_iso88591_A_haq_4z_1D_4_1A_4_1A_Kr_5_gV1_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[37])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 592}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_player_idx}; + __pyx_mstate_global->__pyx_codeobj_tab[38] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_get_valid_actions, __pyx_mstate->__pyx_kp_b_iso88591_A_haq_6_Rq_HF_wat_1_4vQ_1_4v_T_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[38])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 668}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_player_idx}; + __pyx_mstate_global->__pyx_codeobj_tab[39] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_has_valid_moves, __pyx_mstate->__pyx_kp_b_iso88591_A_haq_HF_wat_1_4vQ_1_L_d_4AQ_4_t, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[39])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 9, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 687}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_player_idx, __pyx_mstate->__pyx_n_u_move, __pyx_mstate->__pyx_n_u_player, __pyx_mstate->__pyx_n_u_piece, __pyx_mstate->__pyx_n_u_placed_squares, __pyx_mstate->__pyx_n_u_x, __pyx_mstate->__pyx_n_u_y, __pyx_mstate->__pyx_n_u_placed_corners}; + __pyx_mstate_global->__pyx_codeobj_tab[40] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_apply_move, __pyx_mstate->__pyx_kp_b_iso88591_7q_haq_4z_1D_4_1A_F_Bc_xq_Q_j_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[40])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 715}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_player_idx, __pyx_mstate->__pyx_n_u_action, __pyx_mstate->__pyx_n_u_move}; + __pyx_mstate_global->__pyx_codeobj_tab[41] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_play_move, __pyx_mstate->__pyx_kp_b_iso88591_7q_1A_4t_a_1_1_Kq_A_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[41])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 725}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_offset, __pyx_mstate->__pyx_n_u_next_idx, __pyx_mstate->__pyx_n_u_next_player}; + __pyx_mstate_global->__pyx_codeobj_tab[42] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_next_player, __pyx_mstate->__pyx_kp_b_iso88591_A_4q_4q_Je1Ct_Bhb_A_haq_D_AQ_a_q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[42])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 6, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 744}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_player, __pyx_mstate->__pyx_n_u_player_idx, __pyx_mstate->__pyx_n_u_genexpr, __pyx_mstate->__pyx_n_u_genexpr, __pyx_mstate->__pyx_n_u_genexpr}; + __pyx_mstate_global->__pyx_codeobj_tab[43] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_check_game_over, __pyx_mstate->__pyx_kp_b_iso88591_L_1D_t4_q_l_q_Q_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[43])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 760}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_p}; + __pyx_mstate_global->__pyx_codeobj_tab[44] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_get_state, __pyx_mstate->__pyx_kp_b_iso88591_1_a_4q_d_d_Q_q_1A_AQa_Qa_1A_E_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[44])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 780}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_new_game, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_p}; + __pyx_mstate_global->__pyx_codeobj_tab[45] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_blokus_gym_core_blokus_cython_py, __pyx_mstate->__pyx_n_u_copy, __pyx_mstate->__pyx_kp_b_iso88591_a_Q_t1_4q_A_A_V5_a_a_T_CuIQd_HA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[45])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {1, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 1}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_state, __pyx_mstate->__pyx_n_u_dict_3, __pyx_mstate->__pyx_n_u_use_setstate}; + __pyx_mstate_global->__pyx_codeobj_tab[46] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_reduce_cython, __pyx_mstate->__pyx_kp_b_iso88591_T_9_OtSggkkssw_x_E_E_I_I_W_W_l, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[46])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {2, 0, 0, 2, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 16}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_self, __pyx_mstate->__pyx_n_u_pyx_state}; + __pyx_mstate_global->__pyx_codeobj_tab[47] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_setstate_cython, __pyx_mstate->__pyx_kp_b_iso88591_q_4, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[47])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_type, __pyx_mstate->__pyx_n_u_pyx_checksum, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_pyx_result}; + __pyx_mstate_global->__pyx_codeobj_tab[48] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_Board, __pyx_mstate->__pyx_kp_b_iso88591_q_0_kQR_5_7_q_a_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[48])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_type, __pyx_mstate->__pyx_n_u_pyx_checksum, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_pyx_result}; + __pyx_mstate_global->__pyx_codeobj_tab[49] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_Move, __pyx_mstate->__pyx_kp_b_iso88591_q_0_kQR_4xq_7_awnA_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[49])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_type, __pyx_mstate->__pyx_n_u_pyx_checksum, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_pyx_result}; + __pyx_mstate_global->__pyx_codeobj_tab[50] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_PieceOrientation, __pyx_mstate->__pyx_kp_b_iso88591_q_0_kQR_81A_7_2_3FnTU_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[50])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_type, __pyx_mstate->__pyx_n_u_pyx_checksum, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_pyx_result}; + __pyx_mstate_global->__pyx_codeobj_tab[51] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_Piece, __pyx_mstate->__pyx_kp_b_iso88591_q_0_kQR_5_7_q_a_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[51])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_type, __pyx_mstate->__pyx_n_u_pyx_checksum, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_pyx_result}; + __pyx_mstate_global->__pyx_codeobj_tab[52] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_PieceSet, __pyx_mstate->__pyx_kp_b_iso88591_q_0_kQR_881A_7_nA_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[52])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_type, __pyx_mstate->__pyx_n_u_pyx_checksum, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_pyx_result}; + __pyx_mstate_global->__pyx_codeobj_tab[53] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_PlayerState, __pyx_mstate->__pyx_kp_b_iso88591_q_0_kQR_haq_7_QnN_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[53])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {3, 0, 0, 4, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS), 4}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_pyx_type, __pyx_mstate->__pyx_n_u_pyx_checksum, __pyx_mstate->__pyx_n_u_pyx_state, __pyx_mstate->__pyx_n_u_pyx_result}; + __pyx_mstate_global->__pyx_codeobj_tab[54] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_stringsource, __pyx_mstate->__pyx_n_u_pyx_unpickle_BlokusGame, __pyx_mstate->__pyx_kp_b_iso88591_q_0_kQR_XQa_7_A_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[54])) goto bad; + } + Py_DECREF(tuple_dedup_map); + return 0; + bad: + Py_DECREF(tuple_dedup_map); + return -1; +} +/* #### Code section: init_globals ### */ + +static int __Pyx_InitGlobals(void) { + /* PythonCompatibility.init */ + if (likely(__Pyx_init_co_variables() == 0)); else + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* AssertionsEnabled.init */ + if (likely(__Pyx_init_assertions_enabled() == 0)); else + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* NumpyImportArray.init */ + /* + * Cython has automatically inserted a call to _import_array since + * you didn't include one when you cimported numpy. To disable this + * add the line + * numpy._import_array + */ + #ifdef NPY_FEATURE_VERSION + #ifndef NO_IMPORT_ARRAY + if (unlikely(_import_array() == -1)) { + PyErr_SetString(PyExc_ImportError, "numpy.core.multiarray failed to import " + "(auto-generated because you didn't call 'numpy.import_array()' after cimporting numpy; " + "use 'numpy._import_array' to disable if you are certain you don't need it)."); + } + #endif + #endif + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* CommonTypesMetaclass.init */ + if (likely(__pyx_CommonTypesMetaclass_init(__pyx_m) == 0)); else + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* CachedMethodType.init */ + #if CYTHON_COMPILING_IN_LIMITED_API + { + PyObject *typesModule=NULL; + typesModule = PyImport_ImportModule("types"); + if (typesModule) { + __pyx_mstate_global->__Pyx_CachedMethodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + } + } // error handling follows + #endif + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* CythonFunctionShared.init */ + if (likely(__pyx_CyFunction_init(__pyx_m) == 0)); else + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* Generator.init */ + if (likely(__pyx_Generator_init(__pyx_m) == 0)); else + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: cleanup_globals ### */ +/* #### Code section: cleanup_module ### */ +/* #### Code section: main_method ### */ +/* #### Code section: utility_code_pragmas ### */ +#ifdef _MSC_VER +#pragma warning( push ) +/* Warning 4127: conditional expression is constant + * Cython uses constant conditional expressions to allow in inline functions to be optimized at + * compile-time, so this warning is not useful + */ +#pragma warning( disable : 4127 ) +#endif + + + +/* #### Code section: utility_code_def ### */ + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* PyErrExceptionMatches (used by PyObjectGetAttrStrNoError) */ +#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); + for (i=0; i= 0x030C00A6 + PyObject *current_exception = tstate->current_exception; + if (unlikely(!current_exception)) return 0; + exc_type = (PyObject*) Py_TYPE(current_exception); + if (exc_type == err) return 1; +#else + exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; +#endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(exc_type); + #endif + if (unlikely(PyTuple_Check(err))) { + result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + } else { + result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(exc_type); + #endif + return result; +} +#endif + +/* PyErrFetchRestore (used by PyObjectGetAttrStrNoError) */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject *tmp_value; + assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + if (value) { + #if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) + #endif + PyException_SetTraceback(value, tb); + } + tmp_value = tstate->current_exception; + tstate->current_exception = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject* exc_value; + exc_value = tstate->current_exception; + tstate->current_exception = 0; + *value = exc_value; + *type = NULL; + *tb = NULL; + if (exc_value) { + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + #if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject*) exc_value)->traceback; + Py_XINCREF(*tb); + #else + *tb = PyException_GetTraceback(exc_value); + #endif + } +#else + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#endif +} +#endif + +/* PyObjectGetAttrStr (used by PyObjectGetAttrStrNoError) */ +#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); + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* PyObjectGetAttrStrNoError (used by GetBuiltinName) */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +#endif +} + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { + PyErr_Format(PyExc_NameError, + "name '%U' is not defined", name); + } + return result; +} + +/* TupleAndListFromArray (used by fastcall) */ +#if !CYTHON_COMPILING_IN_CPYTHON && CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + Py_ssize_t i; + if (n <= 0) { + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + for (i = 0; i < n; i++) { + Py_INCREF(src[i]); + if (unlikely(__Pyx_PyTuple_SET_ITEM(res, i, src[i]) < (0))) { + Py_DECREF(res); + return NULL; + } + } + return res; +} +#elif CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { + PyObject *v; + Py_ssize_t i; + for (i = 0; i < length; i++) { + v = dest[i] = src[i]; + Py_INCREF(v); + } +} +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); + return res; +} +static CYTHON_INLINE PyObject * +__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return PyList_New(0); + } + res = PyList_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); + return res; +} +#endif + +/* BytesEquals (used by UnicodeEquals) */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL ||\ + !(CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) + 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 (used by fastcall) */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL + return PyObject_RichCompareBool(s1, s2, equals); +#else + 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 (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length, length2; + int kind; + void *data1, *data2; + #if !CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + #endif + length = __Pyx_PyUnicode_GET_LENGTH(s1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length < 0)) return -1; + #endif + length2 = __Pyx_PyUnicode_GET_LENGTH(s2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length2 < 0)) return -1; + #endif + if (length != length2) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + 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)); + 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_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + return (equals == Py_EQ); +return_ne: + return (equals == Py_NE); +#endif +} + +/* fastcall */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = __Pyx_PyTuple_GET_SIZE(kwnames); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(n == -1)) return NULL; + #endif + for (i = 0; i < n; i++) + { + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + if (s == namei) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + int eq = __Pyx_PyUnicode_Equals(s, namei, Py_EQ); + if (unlikely(eq != 0)) { + if (unlikely(eq < 0)) return NULL; + return kwvalues[i]; + } + } + return NULL; +} +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs; + PyObject *dict; +#if !CYTHON_ASSUME_SAFE_SIZE + nkwargs = PyTuple_Size(kwnames); + if (unlikely(nkwargs < 0)) return NULL; +#else + nkwargs = PyTuple_GET_SIZE(kwnames); +#endif + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; itp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall(" 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 + +/* PyObjectCallMethO (used by PyObjectFastCall) */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall(" 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 + +/* PyObjectFastCall (used by PyObjectCallOneArg) */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs) { + PyObject *argstuple; + PyObject *result = 0; + size_t i; + argstuple = PyTuple_New((Py_ssize_t)nargs); + if (unlikely(!argstuple)) return NULL; + for (i = 0; i < nargs; i++) { + Py_INCREF(args[i]); + if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) != (0)) goto bad; + } + result = __Pyx_PyObject_Call(func, argstuple, kwargs); + bad: + Py_DECREF(argstuple); + return result; +} +#endif +#if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API + #if PY_VERSION_HEX < 0x03090000 + #define __Pyx_PyVectorcall_Function(callable) _PyVectorcall_Function(callable) + #elif CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE vectorcallfunc __Pyx_PyVectorcall_Function(PyObject *callable) { + PyTypeObject *tp = Py_TYPE(callable); + #if defined(__Pyx_CyFunction_USED) && CYTHON_METH_FASTCALL + if (__Pyx_CyFunction_CheckExact(callable)) { + return __Pyx_CyFunction_func_vectorcall(callable); + } + #endif + if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) { + return NULL; + } + assert(PyCallable_Check(callable)); + Py_ssize_t offset = tp->tp_vectorcall_offset; + assert(offset > 0); + vectorcallfunc ptr; + memcpy(&ptr, (char *) callable + offset, sizeof(ptr)); + return ptr; +} + #else + #define __Pyx_PyVectorcall_Function(callable) PyVectorcall_Function(callable) + #endif +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject *const *args, size_t _nargs, PyObject *kwargs) { + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); +#if CYTHON_COMPILING_IN_CPYTHON + if (nargs == 0 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) + return __Pyx_PyObject_CallMethO(func, NULL); + } + else if (nargs == 1 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) + return __Pyx_PyObject_CallMethO(func, args[0]); + } +#endif + if (kwargs == NULL) { + #if CYTHON_VECTORCALL + #if CYTHON_COMPILING_IN_LIMITED_API + return PyObject_Vectorcall(func, args, _nargs, NULL); + #else + vectorcallfunc f = __Pyx_PyVectorcall_Function(func); + if (f) { + return f(func, args, _nargs, NULL); + } + #endif + #endif + } + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_mstate_global->__pyx_empty_tuple, kwargs); + } + #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API + return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); + #else + return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); + #endif +} + +/* PyObjectCallOneArg (used by CallUnboundCMethod0) */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *args[2] = {NULL, arg}; + return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* UnpackUnboundCMethod (used by CallUnboundCMethod0) */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *args, PyObject *kwargs) { + PyObject *result; + PyObject *selfless_args = PyTuple_GetSlice(args, 1, PyTuple_Size(args)); + if (unlikely(!selfless_args)) return NULL; + result = PyObject_Call(method, selfless_args, kwargs); + Py_DECREF(selfless_args); + return result; +} +#elif CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03090000 +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) { + return _PyObject_Vectorcall + (method, args ? args+1 : NULL, nargs ? nargs-1 : 0, kwnames); +} +#else +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) { + return +#if PY_VERSION_HEX < 0x03090000 + _PyObject_Vectorcall +#else + PyObject_Vectorcall +#endif + (method, args ? args+1 : NULL, nargs ? (size_t) nargs-1 : 0, kwnames); +} +#endif +static PyMethodDef __Pyx_UnboundCMethod_Def = { + "CythonUnboundCMethod", + __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall), +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 + METH_VARARGS | METH_KEYWORDS, +#else + METH_FASTCALL | METH_KEYWORDS, +#endif + NULL +}; +static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { + PyObject *method, *result=NULL; + method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name); + if (unlikely(!method)) + return -1; + result = method; +#if CYTHON_COMPILING_IN_CPYTHON + if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) + { + PyMethodDescrObject *descr = (PyMethodDescrObject*) method; + target->func = descr->d_method->ml_meth; + target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS); + } else +#endif +#if CYTHON_COMPILING_IN_PYPY +#else + if (PyCFunction_Check(method)) +#endif + { + PyObject *self; + int self_found; +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + self = PyObject_GetAttrString(method, "__self__"); + if (!self) { + PyErr_Clear(); + } +#else + self = PyCFunction_GET_SELF(method); +#endif + self_found = (self && self != Py_None); +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + Py_XDECREF(self); +#endif + if (self_found) { + PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method); + if (unlikely(!unbound_method)) return -1; + Py_DECREF(method); + result = unbound_method; + } + } +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if (unlikely(target->method)) { + Py_DECREF(result); + } else +#endif + target->method = result; + return 0; +} + +/* CallUnboundCMethod0 */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { + int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); + if (likely(was_initialized == 2 && cfunc->func)) { + if (likely(cfunc->flag == METH_NOARGS)) + return __Pyx_CallCFunction(cfunc, self, NULL); + if (likely(cfunc->flag == METH_FASTCALL)) + return __Pyx_CallCFunctionFast(cfunc, self, NULL, 0); + if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) + return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, NULL, 0, NULL); + if (likely(cfunc->flag == (METH_VARARGS | METH_KEYWORDS))) + return __Pyx_CallCFunctionWithKeywords(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (cfunc->flag == METH_VARARGS) + return __Pyx_CallCFunction(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple); + return __Pyx__CallUnboundCMethod0(cfunc, self); + } +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + else if (unlikely(was_initialized == 1)) { + __Pyx_CachedCFunction tmp_cfunc = { +#ifndef __cplusplus + 0 +#endif + }; + tmp_cfunc.type = cfunc->type; + tmp_cfunc.method_name = cfunc->method_name; + return __Pyx__CallUnboundCMethod0(&tmp_cfunc, self); + } +#endif + PyObject *result = __Pyx__CallUnboundCMethod0(cfunc, self); + __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); + return result; +} +#endif +static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { + PyObject *result; + if (unlikely(!cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; + result = __Pyx_PyObject_CallOneArg(cfunc->method, self); + return result; +} + +/* py_dict_items (used by OwnedDictNext) */ +static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d) { + return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_items, d); +} + +/* py_dict_values (used by OwnedDictNext) */ +static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d) { + return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_values, d); +} + +/* OwnedDictNext (used by ParseKeywordsImpl) */ +#if CYTHON_AVOID_BORROWED_REFS +static int __Pyx_PyDict_NextRef(PyObject *p, PyObject **ppos, PyObject **pkey, PyObject **pvalue) { + PyObject *next = NULL; + if (!*ppos) { + if (pvalue) { + PyObject *dictview = pkey ? __Pyx_PyDict_Items(p) : __Pyx_PyDict_Values(p); + if (unlikely(!dictview)) goto bad; + *ppos = PyObject_GetIter(dictview); + Py_DECREF(dictview); + } else { + *ppos = PyObject_GetIter(p); + } + if (unlikely(!*ppos)) goto bad; + } + next = PyIter_Next(*ppos); + if (!next) { + if (PyErr_Occurred()) goto bad; + return 0; + } + if (pkey && pvalue) { + *pkey = __Pyx_PySequence_ITEM(next, 0); + if (unlikely(*pkey)) goto bad; + *pvalue = __Pyx_PySequence_ITEM(next, 1); + if (unlikely(*pvalue)) goto bad; + Py_DECREF(next); + } else if (pkey) { + *pkey = next; + } else { + assert(pvalue); + *pvalue = next; + } + return 1; + bad: + Py_XDECREF(next); +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 + PyErr_FormatUnraisable("Exception ignored in __Pyx_PyDict_NextRef"); +#else + PyErr_WriteUnraisable(__pyx_mstate_global->__pyx_n_u_Pyx_PyDict_NextRef); +#endif + if (pkey) *pkey = NULL; + if (pvalue) *pvalue = NULL; + return 0; +} +#else // !CYTHON_AVOID_BORROWED_REFS +static int __Pyx_PyDict_NextRef(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue) { + int result = PyDict_Next(p, ppos, pkey, pvalue); + if (likely(result == 1)) { + if (pkey) Py_INCREF(*pkey); + if (pvalue) Py_INCREF(*pvalue); + } + return result; +} +#endif + +/* RaiseDoubleKeywords (used by ParseKeywordsImpl) */ +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); +} + +/* CallUnboundCMethod2 */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) { + int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); + if (likely(was_initialized == 2 && cfunc->func)) { + PyObject *args[2] = {arg1, arg2}; + if (cfunc->flag == METH_FASTCALL) { + return __Pyx_CallCFunctionFast(cfunc, self, args, 2); + } + if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) + return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, 2, NULL); + } +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + else if (unlikely(was_initialized == 1)) { + __Pyx_CachedCFunction tmp_cfunc = { +#ifndef __cplusplus + 0 +#endif + }; + tmp_cfunc.type = cfunc->type; + tmp_cfunc.method_name = cfunc->method_name; + return __Pyx__CallUnboundCMethod2(&tmp_cfunc, self, arg1, arg2); + } +#endif + PyObject *result = __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2); + __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); + return result; +} +#endif +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){ + if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; +#if CYTHON_COMPILING_IN_CPYTHON + if (cfunc->func && (cfunc->flag & METH_VARARGS)) { + PyObject *result = NULL; + PyObject *args = PyTuple_New(2); + if (unlikely(!args)) return NULL; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + if (cfunc->flag & METH_KEYWORDS) + result = __Pyx_CallCFunctionWithKeywords(cfunc, self, args, NULL); + else + result = __Pyx_CallCFunction(cfunc, self, args); + Py_DECREF(args); + return result; + } +#endif + { + PyObject *args[4] = {NULL, self, arg1, arg2}; + return __Pyx_PyObject_FastCall(cfunc->method, args+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); + } +} + +/* ParseKeywordsImpl (used by ParseKeywords) */ +static int __Pyx_ValidateDuplicatePosArgs( + PyObject *kwds, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + const char* function_name) +{ + PyObject ** const *name = argnames; + while (name != first_kw_arg) { + PyObject *key = **name; + int found = PyDict_Contains(kwds, key); + if (unlikely(found)) { + if (found == 1) __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; + } + name++; + } + return 0; +bad: + return -1; +} +#if CYTHON_USE_UNICODE_INTERNALS +static CYTHON_INLINE int __Pyx_UnicodeKeywordsEqual(PyObject *s1, PyObject *s2) { + int kind; + Py_ssize_t len = PyUnicode_GET_LENGTH(s1); + if (len != PyUnicode_GET_LENGTH(s2)) return 0; + kind = PyUnicode_KIND(s1); + if (kind != PyUnicode_KIND(s2)) return 0; + const void *data1 = PyUnicode_DATA(s1); + const void *data2 = PyUnicode_DATA(s2); + return (memcmp(data1, data2, (size_t) len * (size_t) kind) == 0); +} +#endif +static int __Pyx_MatchKeywordArg_str( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + PyObject ** const *name; + #if CYTHON_USE_UNICODE_INTERNALS + Py_hash_t key_hash = ((PyASCIIObject*)key)->hash; + if (unlikely(key_hash == -1)) { + key_hash = PyObject_Hash(key); + if (unlikely(key_hash == -1)) + goto bad; + } + #endif + name = first_kw_arg; + while (*name) { + PyObject *name_str = **name; + #if CYTHON_USE_UNICODE_INTERNALS + if (key_hash == ((PyASCIIObject*)name_str)->hash && __Pyx_UnicodeKeywordsEqual(name_str, key)) { + *index_found = (size_t) (name - argnames); + return 1; + } + #else + #if CYTHON_ASSUME_SAFE_SIZE + if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) + #endif + { + int cmp = PyUnicode_Compare(name_str, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + *index_found = (size_t) (name - argnames); + return 1; + } + } + #endif + name++; + } + name = argnames; + while (name != first_kw_arg) { + PyObject *name_str = **name; + #if CYTHON_USE_UNICODE_INTERNALS + if (unlikely(key_hash == ((PyASCIIObject*)name_str)->hash)) { + if (__Pyx_UnicodeKeywordsEqual(name_str, key)) + goto arg_passed_twice; + } + #else + #if CYTHON_ASSUME_SAFE_SIZE + if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) + #endif + { + if (unlikely(name_str == key)) goto arg_passed_twice; + int cmp = PyUnicode_Compare(name_str, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + } + #endif + name++; + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +bad: + return -1; +} +static int __Pyx_MatchKeywordArg_nostr( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + PyObject ** const *name; + if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; + name = first_kw_arg; + while (*name) { + int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); + if (cmp == 1) { + *index_found = (size_t) (name - argnames); + return 1; + } + if (unlikely(cmp == -1)) goto bad; + name++; + } + name = argnames; + while (name != first_kw_arg) { + int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); + if (unlikely(cmp != 0)) { + if (cmp == 1) goto arg_passed_twice; + else goto bad; + } + name++; + } + 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; +bad: + return -1; +} +static CYTHON_INLINE int __Pyx_MatchKeywordArg( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + return likely(PyUnicode_CheckExact(key)) ? + __Pyx_MatchKeywordArg_str(key, argnames, first_kw_arg, index_found, function_name) : + __Pyx_MatchKeywordArg_nostr(key, argnames, first_kw_arg, index_found, function_name); +} +static void __Pyx_RejectUnknownKeyword( + PyObject *kwds, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + const char *function_name) +{ + #if CYTHON_AVOID_BORROWED_REFS + PyObject *pos = NULL; + #else + Py_ssize_t pos = 0; + #endif + PyObject *key = NULL; + __Pyx_BEGIN_CRITICAL_SECTION(kwds); + while ( + #if CYTHON_AVOID_BORROWED_REFS + __Pyx_PyDict_NextRef(kwds, &pos, &key, NULL) + #else + PyDict_Next(kwds, &pos, &key, NULL) + #endif + ) { + PyObject** const *name = first_kw_arg; + while (*name && (**name != key)) name++; + if (!*name) { + size_t index_found = 0; + int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); + if (cmp != 1) { + if (cmp == 0) { + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + #endif + break; + } + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + #endif + } + __Pyx_END_CRITICAL_SECTION(); + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(pos); + #endif + assert(PyErr_Occurred()); +} +static int __Pyx_ParseKeywordDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + PyObject** const *name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + Py_ssize_t extracted = 0; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; +#endif + name = first_kw_arg; + while (*name && num_kwargs > extracted) { + PyObject * key = **name; + PyObject *value; + int found = 0; + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + found = PyDict_GetItemRef(kwds, key, &value); + #else + value = PyDict_GetItemWithError(kwds, key); + if (value) { + Py_INCREF(value); + found = 1; + } else { + if (unlikely(PyErr_Occurred())) goto bad; + } + #endif + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + extracted++; + } + name++; + } + if (num_kwargs > extracted) { + if (ignore_unknown_kwargs) { + if (unlikely(__Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name) == -1)) + goto bad; + } else { + __Pyx_RejectUnknownKeyword(kwds, argnames, first_kw_arg, function_name); + goto bad; + } + } + return 0; +bad: + return -1; +} +static int __Pyx_ParseKeywordDictToDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject** const *name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + Py_ssize_t len; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; +#endif + if (PyDict_Update(kwds2, kwds) < 0) goto bad; + name = first_kw_arg; + while (*name) { + PyObject *key = **name; + PyObject *value; +#if !CYTHON_COMPILING_IN_LIMITED_API && (PY_VERSION_HEX >= 0x030d00A2 || defined(PyDict_Pop)) + int found = PyDict_Pop(kwds2, key, &value); + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + } +#elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + int found = PyDict_GetItemRef(kwds2, key, &value); + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + if (unlikely(PyDict_DelItem(kwds2, key) < 0)) goto bad; + } +#else + #if CYTHON_COMPILING_IN_CPYTHON + value = _PyDict_Pop(kwds2, key, kwds2); + #else + value = __Pyx_CallUnboundCMethod2(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_pop, kwds2, key, kwds2); + #endif + if (value == kwds2) { + Py_DECREF(value); + } else { + if (unlikely(!value)) goto bad; + values[name-argnames] = value; + } +#endif + name++; + } + len = PyDict_Size(kwds2); + if (len > 0) { + return __Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name); + } else if (unlikely(len == -1)) { + goto bad; + } + return 0; +bad: + return -1; +} +static int __Pyx_ParseKeywordsTuple( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + PyObject *key = NULL; + PyObject** const * name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + for (Py_ssize_t pos = 0; pos < num_kwargs; pos++) { +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); +#else + key = __Pyx_PyTuple_GET_ITEM(kwds, pos); +#endif +#if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!key)) goto bad; +#endif + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + PyObject *value = kwvalues[pos]; + values[name-argnames] = __Pyx_NewRef(value); + } else { + size_t index_found = 0; + int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); + if (cmp == 1) { + PyObject *value = kwvalues[pos]; + values[index_found] = __Pyx_NewRef(value); + } else { + if (unlikely(cmp == -1)) goto bad; + if (kwds2) { + PyObject *value = kwvalues[pos]; + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else if (!ignore_unknown_kwargs) { + goto invalid_keyword; + } + } + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + key = NULL; + #endif + } + return 0; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + goto bad; +bad: + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(key); + #endif + return -1; +} + +/* ParseKeywords */ +static int __Pyx_ParseKeywords( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds))) + return __Pyx_ParseKeywordsTuple(kwds, kwvalues, argnames, kwds2, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); + else if (kwds2) + return __Pyx_ParseKeywordDictToDict(kwds, argnames, kwds2, values, num_pos_args, function_name); + else + return __Pyx_ParseKeywordDict(kwds, argnames, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); +} + +/* 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); +} + +/* ArgTypeTestFunc (used by ArgTypeTest) */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + __Pyx_TypeName type_name; + __Pyx_TypeName obj_type_name; + PyObject *extra_info = __pyx_mstate_global->__pyx_empty_unicode; + int from_annotation_subclass = 0; + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (!exact) { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } else if (exact == 2) { + if (__Pyx_TypeCheck(obj, type)) { + from_annotation_subclass = 1; + extra_info = __pyx_mstate_global->__pyx_kp_u_Note_that_Cython_is_deliberately; + } + } + type_name = __Pyx_PyType_GetFullyQualifiedName(type); + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME + ", got " __Pyx_FMT_TYPENAME ")" +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 + "%s%U" +#endif + , name, type_name, obj_type_name +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 + , (from_annotation_subclass ? ". " : ""), extra_info +#endif + ); +#if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + if (exact == 2 && from_annotation_subclass) { + PyObject *res; + PyObject *vargs[2]; + vargs[0] = PyErr_GetRaisedException(); + vargs[1] = extra_info; + res = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_kp_u_add_note, vargs, 2, NULL); + Py_XDECREF(res); + PyErr_SetRaisedException(vargs[0]); + } +#endif + __Pyx_DECREF_TypeName(type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return 0; +} + +/* RaiseException */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyException_SetTraceback(value, tb); +#elif CYTHON_FAST_THREAD_STATE + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} + +/* PyObjectFastCallMethod */ +#if !CYTHON_VECTORCALL || PY_VERSION_HEX < 0x03090000 +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf) { + PyObject *result; + PyObject *attr = PyObject_GetAttr(args[0], name); + if (unlikely(!attr)) + return NULL; + result = __Pyx_PyObject_FastCall(attr, args+1, nargsf - 1); + Py_DECREF(attr); + return result; +} +#endif + +/* RaiseUnexpectedTypeError */ +static int +__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) +{ + __Pyx_TypeName obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME, + expected, obj_type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return 0; +} + +/* CIntToDigits (used by CIntToPyUnicode) */ +static const char DIGIT_PAIRS_10[2*10*10+1] = { + "00010203040506070809" + "10111213141516171819" + "20212223242526272829" + "30313233343536373839" + "40414243444546474849" + "50515253545556575859" + "60616263646566676869" + "70717273747576777879" + "80818283848586878889" + "90919293949596979899" +}; +static const char DIGIT_PAIRS_8[2*8*8+1] = { + "0001020304050607" + "1011121314151617" + "2021222324252627" + "3031323334353637" + "4041424344454647" + "5051525354555657" + "6061626364656667" + "7071727374757677" +}; +static const char DIGITS_HEX[2*16+1] = { + "0123456789abcdef" + "0123456789ABCDEF" +}; + +/* BuildPyUnicode (used by COrdinalToPyUnicode) */ +static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, const char* chars, int clength, + int prepend_sign, char padding_char) { + PyObject *uval; + Py_ssize_t uoffset = ulength - clength; +#if CYTHON_USE_UNICODE_INTERNALS + Py_ssize_t i; + void *udata; + uval = PyUnicode_New(ulength, 127); + if (unlikely(!uval)) return NULL; + udata = PyUnicode_DATA(uval); + if (uoffset > 0) { + i = 0; + if (prepend_sign) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-'); + i++; + } + for (; i < uoffset; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char); + } + } + for (i=0; i < clength; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]); + } +#else + { + PyObject *sign = NULL, *padding = NULL; + uval = NULL; + if (uoffset > 0) { + prepend_sign = !!prepend_sign; + if (uoffset > prepend_sign) { + padding = PyUnicode_FromOrdinal(padding_char); + if (likely(padding) && uoffset > prepend_sign + 1) { + PyObject *tmp = PySequence_Repeat(padding, uoffset - prepend_sign); + Py_DECREF(padding); + padding = tmp; + } + if (unlikely(!padding)) goto done_or_error; + } + if (prepend_sign) { + sign = PyUnicode_FromOrdinal('-'); + if (unlikely(!sign)) goto done_or_error; + } + } + uval = PyUnicode_DecodeASCII(chars, clength, NULL); + if (likely(uval) && padding) { + PyObject *tmp = PyUnicode_Concat(padding, uval); + Py_DECREF(uval); + uval = tmp; + } + if (likely(uval) && sign) { + PyObject *tmp = PyUnicode_Concat(sign, uval); + Py_DECREF(uval); + uval = tmp; + } +done_or_error: + Py_XDECREF(padding); + Py_XDECREF(sign); + } +#endif + return uval; +} + +/* COrdinalToPyUnicode (used by CIntToPyUnicode) */ +static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value) { + return value <= 1114111; +} +static PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t ulength, char padding_char) { + Py_ssize_t padding_length = ulength - 1; + if (likely((padding_length <= 250) && (value < 0xD800 || value > 0xDFFF))) { + char chars[256]; + if (value <= 255) { + memset(chars, padding_char, (size_t) padding_length); + chars[ulength-1] = (char) value; + return PyUnicode_DecodeLatin1(chars, ulength, NULL); + } + char *cpos = chars + sizeof(chars); + if (value < 0x800) { + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0xc0 | (value & 0x1f)); + } else if (value < 0x10000) { + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0xe0 | (value & 0x0f)); + } else { + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0xf0 | (value & 0x07)); + } + cpos -= padding_length; + memset(cpos, padding_char, (size_t) padding_length); + return PyUnicode_DecodeUTF8(cpos, chars + sizeof(chars) - cpos, NULL); + } + if (value <= 127 && CYTHON_USE_UNICODE_INTERNALS) { + const char chars[1] = {(char) value}; + return __Pyx_PyUnicode_BuildFromAscii(ulength, chars, 1, 0, padding_char); + } + { + PyObject *uchar, *padding_uchar, *padding, *result; + padding_uchar = PyUnicode_FromOrdinal(padding_char); + if (unlikely(!padding_uchar)) return NULL; + padding = PySequence_Repeat(padding_uchar, padding_length); + Py_DECREF(padding_uchar); + if (unlikely(!padding)) return NULL; + uchar = PyUnicode_FromOrdinal(value); + if (unlikely(!uchar)) { + Py_DECREF(padding); + return NULL; + } + result = PyUnicode_Concat(padding, uchar); + Py_DECREF(padding); + Py_DECREF(uchar); + return result; + } +} + +/* CIntToPyUnicode */ +static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char) { +#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 (unlikely(!(is_unsigned || value == 0 || value > 0) || + !(sizeof(value) <= 2 || value & ~ (int) 0x01fffff || __Pyx_CheckUnicodeValue((int) value)))) { + PyErr_SetString(PyExc_OverflowError, "%c arg not in range(0x110000)"); + return NULL; + } + if (width <= 1) { + return PyUnicode_FromOrdinal((int) value); + } + return __Pyx_PyUnicode_FromOrdinal_Padded((int) value, width, padding_char); +} +static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char) { + char digits[sizeof(int)*3+2]; + char *dpos, *end = digits + sizeof(int)*3+2; + const char *hex_digits = DIGITS_HEX; + Py_ssize_t length, ulength; + int prepend_sign, last_one_off; + int remaining; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (format_char == 'X') { + hex_digits += 16; + format_char = 'x'; + } + remaining = value; + last_one_off = 0; + dpos = end; + do { + int digit_pos; + switch (format_char) { + case 'o': + digit_pos = abs((int)(remaining % (8*8))); + remaining = (int) (remaining / (8*8)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); + last_one_off = (digit_pos < 8); + break; + case 'd': + digit_pos = abs((int)(remaining % (10*10))); + remaining = (int) (remaining / (10*10)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); + last_one_off = (digit_pos < 10); + break; + case 'x': + *(--dpos) = hex_digits[abs((int)(remaining % 16))]; + remaining = (int) (remaining / 16); + break; + default: + assert(0); + break; + } + } while (unlikely(remaining != 0)); + assert(!last_one_off || *dpos == '0'); + dpos += last_one_off; + length = end - dpos; + ulength = length; + prepend_sign = 0; + if (!is_unsigned && value <= neg_one) { + if (padding_char == ' ' || width <= length + 1) { + *(--dpos) = '-'; + ++length; + } else { + prepend_sign = 1; + } + ++ulength; + } + if (width > ulength) { + ulength = width; + } + if (ulength == 1) { + return PyUnicode_FromOrdinal(*dpos); + } + return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); +} + +/* CIntToPyUnicode */ +static CYTHON_INLINE PyObject* __Pyx_uchar___Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char) { +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const Py_ssize_t neg_one = (Py_ssize_t) -1, const_zero = (Py_ssize_t) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!(is_unsigned || value == 0 || value > 0) || + !(sizeof(value) <= 2 || value & ~ (Py_ssize_t) 0x01fffff || __Pyx_CheckUnicodeValue((int) value)))) { + PyErr_SetString(PyExc_OverflowError, "%c arg not in range(0x110000)"); + return NULL; + } + if (width <= 1) { + return PyUnicode_FromOrdinal((int) value); + } + return __Pyx_PyUnicode_FromOrdinal_Padded((int) value, width, padding_char); +} +static CYTHON_INLINE PyObject* __Pyx____Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char) { + char digits[sizeof(Py_ssize_t)*3+2]; + char *dpos, *end = digits + sizeof(Py_ssize_t)*3+2; + const char *hex_digits = DIGITS_HEX; + Py_ssize_t length, ulength; + int prepend_sign, last_one_off; + Py_ssize_t remaining; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const Py_ssize_t neg_one = (Py_ssize_t) -1, const_zero = (Py_ssize_t) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (format_char == 'X') { + hex_digits += 16; + format_char = 'x'; + } + remaining = value; + last_one_off = 0; + dpos = end; + do { + int digit_pos; + switch (format_char) { + case 'o': + digit_pos = abs((int)(remaining % (8*8))); + remaining = (Py_ssize_t) (remaining / (8*8)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); + last_one_off = (digit_pos < 8); + break; + case 'd': + digit_pos = abs((int)(remaining % (10*10))); + remaining = (Py_ssize_t) (remaining / (10*10)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); + last_one_off = (digit_pos < 10); + break; + case 'x': + *(--dpos) = hex_digits[abs((int)(remaining % 16))]; + remaining = (Py_ssize_t) (remaining / 16); + break; + default: + assert(0); + break; + } + } while (unlikely(remaining != 0)); + assert(!last_one_off || *dpos == '0'); + dpos += last_one_off; + length = end - dpos; + ulength = length; + prepend_sign = 0; + if (!is_unsigned && value <= neg_one) { + if (padding_char == ' ' || width <= length + 1) { + *(--dpos) = '-'; + ++length; + } else { + prepend_sign = 1; + } + ++ulength; + } + if (width > ulength) { + ulength = width; + } + if (ulength == 1) { + return PyUnicode_FromOrdinal(*dpos); + } + return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); +} + +/* JoinPyUnicode */ +static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char) { +#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + PyObject *result_uval; + int result_ukind, kind_shift; + Py_ssize_t i, char_pos; + void *result_udata; + if (max_char > 1114111) max_char = 1114111; + result_uval = PyUnicode_New(result_ulength, max_char); + if (unlikely(!result_uval)) return NULL; + result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; + kind_shift = (result_ukind == PyUnicode_4BYTE_KIND) ? 2 : result_ukind - 1; + result_udata = PyUnicode_DATA(result_uval); + assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - result_ulength < 0)) + goto overflow; + char_pos = 0; + for (i=0; i < value_count; i++) { + int ukind; + Py_ssize_t ulength; + void *udata; + PyObject *uval = values[i]; + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_PyUnicode_READY(uval) == (-1)) + goto bad; + #endif + ulength = __Pyx_PyUnicode_GET_LENGTH(uval); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(ulength < 0)) goto bad; + #endif + if (unlikely(!ulength)) + continue; + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos)) + goto overflow; + ukind = __Pyx_PyUnicode_KIND(uval); + udata = __Pyx_PyUnicode_DATA(uval); + if (ukind == result_ukind) { + memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift)); + } else { + #if PY_VERSION_HEX >= 0x030d0000 + if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad; + #elif CYTHON_COMPILING_IN_CPYTHON || defined(_PyUnicode_FastCopyCharacters) + _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); + #else + Py_ssize_t j; + for (j=0; j < ulength; j++) { + Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); + __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); + } + #endif + } + char_pos += ulength; + } + return result_uval; +overflow: + PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); +bad: + Py_DECREF(result_uval); + return NULL; +#else + Py_ssize_t i; + PyObject *result = NULL; + PyObject *value_tuple = PyTuple_New(value_count); + if (unlikely(!value_tuple)) return NULL; + CYTHON_UNUSED_VAR(max_char); + CYTHON_UNUSED_VAR(result_ulength); + for (i=0; i__pyx_empty_unicode, value_tuple); +bad: + Py_DECREF(value_tuple); + return result; +#endif +} + +/* GetAttr */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { +#if CYTHON_USE_TYPE_SLOTS + if (likely(PyUnicode_Check(n))) + 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 (unlikely(!j)) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static PyObject *__Pyx_GetItemInt_Generic_size(PyObject *o, Py_ssize_t i) { + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck, int unsafe_shared) { + CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); +#if CYTHON_AVOID_BORROWED_REFS + CYTHON_UNUSED_VAR(boundscheck); + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + Py_ssize_t size = __Pyx_PyList_GET_SIZE(o); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(size < 0)) return NULL; + #endif + wrapped_i += size; + } + return __Pyx_PyList_GetItemRef(o, wrapped_i); +#elif CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS + Py_ssize_t wrapped_i = i; + Py_ssize_t size = (wraparound | boundscheck) ? PyList_GET_SIZE(o) : -1; + if (wraparound & unlikely(i < 0)) { + wrapped_i += size; + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, size))) { + return __Pyx_PyList_GET_ITEM_REF(o, wrapped_i, unsafe_shared); + } + return __Pyx_GetItemInt_Generic_size(o, i); +#else + (void)wraparound; + (void)boundscheck; + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck, int unsafe_shared) { + CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); +#if CYTHON_AVOID_BORROWED_REFS + CYTHON_UNUSED_VAR(boundscheck); + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(o); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(size < 0)) return NULL; + #endif + wrapped_i += size; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_COMPILING_IN_LIMITED_API + return PySequence_ITEM(o, wrapped_i); + #else + if (unlikely(wrapped_i < 0)) { + PyErr_SetString(PyExc_IndexError, "tuple index out of range"); + return NULL; + } + return PySequence_GetItem(o, wrapped_i); + #endif +#elif CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS + Py_ssize_t wrapped_i = i; + Py_ssize_t size = (wraparound | boundscheck) ? PyTuple_GET_SIZE(o) : -1; + if (wraparound & unlikely(i < 0)) { + wrapped_i += size; + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, size))) { + return __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(o, wrapped_i)); + } + return __Pyx_GetItemInt_Generic_size(o, i); +#else + (void)wraparound; + (void)boundscheck; + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + int wraparound, int boundscheck, int unsafe_shared) { + CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + return boundscheck ? __Pyx_PyList_GetItemRef(o, n) : __Pyx_PyList_GET_ITEM_REF(o, n, unsafe_shared); + } else + #if !CYTHON_AVOID_BORROWED_REFS + 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)))) { + return __Pyx_NewRef(PyTuple_GET_ITEM(o, n)); + } + } else + #endif +#else + if ((!wraparound || i >= 0) & PyList_CheckExact(o)) { + return boundscheck ? __Pyx_PyList_GetItemRef(o, i) : __Pyx_PyList_GET_ITEM_REF(o, i, unsafe_shared); + } else +#endif +#if CYTHON_USE_TYPE_SLOTS && !CYTHON_COMPILING_IN_PYPY + { + PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; + PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; + if (!is_list && mm && mm->mp_subscript) { + PyObject *r, *key = PyLong_FromSsize_t(i); + if (unlikely(!key)) return NULL; + r = mm->mp_subscript(o, key); + Py_DECREF(key); + return r; + } + if (is_list || likely(sm && sm->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { + Py_ssize_t l = sm->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return sm->sq_item(o, i); + } + } +#else + if (is_list || !PyMapping_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + (void)wraparound; + (void)boundscheck; + return __Pyx_GetItemInt_Generic_size(o, i); +} + +/* ObjectGetItem */ +#if CYTHON_USE_TYPE_SLOTS +static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject *index) { + PyObject *runerr = NULL; + Py_ssize_t key_value; + key_value = __Pyx_PyIndex_AsSsize_t(index); + if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { + return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1, 1); + } + if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { + __Pyx_TypeName index_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(index)); + PyErr_Clear(); + PyErr_Format(PyExc_IndexError, + "cannot fit '" __Pyx_FMT_TYPENAME "' into an index-sized integer", index_type_name); + __Pyx_DECREF_TypeName(index_type_name); + } + return NULL; +} +static PyObject *__Pyx_PyObject_GetItem_Slow(PyObject *obj, PyObject *key) { + __Pyx_TypeName obj_type_name; + if (likely(PyType_Check(obj))) { + #if __PYX_LIMITED_VERSION_HEX >= 0x03090000 + if ((PyTypeObject*)obj == &PyType_Type) { + return Py_GenericAlias(obj, key); + } + #endif + PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(obj, __pyx_mstate_global->__pyx_n_u_class_getitem); + if (!meth) { + PyErr_Clear(); + } else { + PyObject *result = __Pyx_PyObject_CallOneArg(meth, key); + Py_DECREF(meth); + return result; + } + } + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "'" __Pyx_FMT_TYPENAME "' object is not subscriptable", obj_type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return NULL; +} +static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key) { + PyTypeObject *tp = Py_TYPE(obj); + PyMappingMethods *mm = tp->tp_as_mapping; + PySequenceMethods *sm = tp->tp_as_sequence; + if (likely(mm && mm->mp_subscript)) { + return mm->mp_subscript(obj, key); + } + if (likely(sm && sm->sq_item)) { + return __Pyx_PyObject_GetIndex(obj, key); + } + return __Pyx_PyObject_GetItem_Slow(obj, key); +} +#endif + +/* RejectKeywords */ +static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds) { + PyObject *key = NULL; + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds))) { + key = __Pyx_PySequence_ITEM(kwds, 0); + } else { +#if CYTHON_AVOID_BORROWED_REFS + PyObject *pos = NULL; +#else + Py_ssize_t pos = 0; +#endif +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return; +#endif + __Pyx_PyDict_NextRef(kwds, &pos, &key, NULL); +#if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(pos); +#endif + } + if (likely(key)) { + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + Py_DECREF(key); + } +} + +/* DivInt[Py_ssize_t] */ +static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t a, Py_ssize_t b, int b_is_constant) { + Py_ssize_t q = a / b; + Py_ssize_t r = a - q*b; + Py_ssize_t adapt_python = (b_is_constant ? + ((r != 0) & ((r < 0) ^ (b < 0))) : + ((r != 0) & ((r ^ b) < 0)) + ); + return q - adapt_python; +} + +/* GetAttr3 */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static PyObject *__Pyx_GetAttr3Default(PyObject *d) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + return NULL; + __Pyx_PyErr_Clear(); + Py_INCREF(d); + return d; +} +#endif +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { + PyObject *r; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + int res = PyObject_GetOptionalAttr(o, n, &r); + return (res != 0) ? r : __Pyx_NewRef(d); +#else + #if CYTHON_USE_TYPE_SLOTS + if (likely(PyUnicode_Check(n))) { + r = __Pyx_PyObject_GetAttrStrNoError(o, n); + if (unlikely(!r) && likely(!PyErr_Occurred())) { + r = __Pyx_NewRef(d); + } + return r; + } + #endif + r = PyObject_GetAttr(o, n); + return (likely(r)) ? r : __Pyx_GetAttr3Default(d); +#endif +} + +/* PyDictVersioning (used by GetModuleGlobalName) */ +#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_COMPILING_IN_LIMITED_API + if (unlikely(!__pyx_m)) { + if (!PyErr_Occurred()) + PyErr_SetNone(PyExc_NameError); + return NULL; + } + result = PyObject_GetAttr(__pyx_m, name); + if (likely(result)) { + return result; + } + PyErr_Clear(); +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + if (unlikely(__Pyx_PyDict_GetItemRef(__pyx_mstate_global->__pyx_d, name, &result) == -1)) PyErr_Clear(); + __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return result; + } +#else + result = _PyDict_GetItem_KnownHash(__pyx_mstate_global->__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__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) { + __Pyx_TypeName obj_type_name; + __Pyx_TypeName type_name; + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + type_name = __Pyx_PyType_GetFullyQualifiedName(type); + PyErr_Format(PyExc_TypeError, + "Cannot convert " __Pyx_FMT_TYPENAME " to " __Pyx_FMT_TYPENAME, + obj_type_name, type_name); + __Pyx_DECREF_TypeName(obj_type_name); + __Pyx_DECREF_TypeName(type_name); + return 0; +} + +/* GetTopmostException (used by SaveResetException) */ +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; + } + return exc_info; +} +#endif + +/* SaveResetException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + PyObject *exc_value = exc_info->exc_value; + if (exc_value == NULL || exc_value == Py_None) { + *value = NULL; + *type = NULL; + *tb = NULL; + } else { + *value = exc_value; + Py_INCREF(*value); + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + *tb = PyException_GetTraceback(exc_value); + } + #elif CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); + #endif +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + PyObject *tmp_value = exc_info->exc_value; + exc_info->exc_value = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); + #else + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); + #endif +} +#endif + +/* GetException */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) +#endif +{ + PyObject *local_type = NULL, *local_value, *local_tb = NULL; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if PY_VERSION_HEX >= 0x030C0000 + local_value = tstate->current_exception; + tstate->current_exception = 0; + #else + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + #endif +#elif __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + local_value = PyErr_GetRaisedException(); +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + if (likely(local_value)) { + local_type = (PyObject*) Py_TYPE(local_value); + Py_INCREF(local_type); + local_tb = PyException_GetTraceback(local_value); + } +#else + 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 (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } +#endif // __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + #if PY_VERSION_HEX >= 0x030B00a4 + tmp_value = exc_info->exc_value; + exc_info->exc_value = local_value; + tmp_type = NULL; + tmp_tb = NULL; + Py_XDECREF(local_type); + Py_XDECREF(local_tb); + #else + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + #endif + } + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#elif __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + PyErr_SetHandledException(local_value); + Py_XDECREF(local_value); + Py_XDECREF(local_type); + Py_XDECREF(local_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +#endif +} + +/* SwapException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_value = exc_info->exc_value; + exc_info->exc_value = *value; + if (tmp_value == NULL || tmp_value == Py_None) { + Py_XDECREF(tmp_value); + tmp_value = NULL; + tmp_type = NULL; + tmp_tb = NULL; + } else { + tmp_type = (PyObject*) Py_TYPE(tmp_value); + Py_INCREF(tmp_type); + #if CYTHON_COMPILING_IN_CPYTHON + tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback; + Py_XINCREF(tmp_tb); + #else + tmp_tb = PyException_GetTraceback(tmp_value); + #endif + } + #elif CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = *type; + exc_info->exc_value = *value; + exc_info->exc_traceback = *tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = *type; + tstate->exc_value = *value; + tstate->exc_traceback = *tb; + #endif + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); + PyErr_SetExcInfo(*type, *value, *tb); + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#endif + +/* HasAttr (used by ImportImpl) */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { + PyObject *r; + if (unlikely(!PyUnicode_Check(n))) { + PyErr_SetString(PyExc_TypeError, + "hasattr(): attribute name must be string"); + return -1; + } + r = __Pyx_PyObject_GetAttrStrNoError(o, n); + if (!r) { + return (unlikely(PyErr_Occurred())) ? -1 : 0; + } else { + Py_DECREF(r); + return 1; + } +} +#endif + +/* ImportImpl (used by Import) */ +static int __Pyx__Import_GetModule(PyObject *qualname, PyObject **module) { + PyObject *imported_module = PyImport_GetModule(qualname); + if (unlikely(!imported_module)) { + *module = NULL; + if (PyErr_Occurred()) { + return -1; + } + return 0; + } + *module = imported_module; + return 1; +} +static int __Pyx__Import_Lookup(PyObject *qualname, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject **module) { + PyObject *imported_module; + PyObject *top_level_package_name; + Py_ssize_t i; + int status, module_found; + Py_ssize_t dot_index; + module_found = __Pyx__Import_GetModule(qualname, &imported_module); + if (unlikely(!module_found || module_found == -1)) { + *module = NULL; + return module_found; + } + if (imported_names) { + for (i = 0; i < len_imported_names; i++) { + PyObject *imported_name = imported_names[i]; +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 + int has_imported_attribute = PyObject_HasAttr(imported_module, imported_name); +#else + int has_imported_attribute = PyObject_HasAttrWithError(imported_module, imported_name); + if (unlikely(has_imported_attribute == -1)) goto error; +#endif + if (!has_imported_attribute) { + goto not_found; + } + } + *module = imported_module; + return 1; + } + dot_index = PyUnicode_FindChar(qualname, '.', 0, PY_SSIZE_T_MAX, 1); + if (dot_index == -1) { + *module = imported_module; + return 1; + } + if (unlikely(dot_index == -2)) goto error; + top_level_package_name = PyUnicode_Substring(qualname, 0, dot_index); + if (unlikely(!top_level_package_name)) goto error; + Py_DECREF(imported_module); + status = __Pyx__Import_GetModule(top_level_package_name, module); + Py_DECREF(top_level_package_name); + return status; +error: + Py_DECREF(imported_module); + *module = NULL; + return -1; +not_found: + Py_DECREF(imported_module); + *module = NULL; + return 0; +} +static PyObject *__Pyx__Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, PyObject *moddict, int level) { + PyObject *module = 0; + PyObject *empty_dict = 0; + PyObject *from_list = 0; + int module_found; + if (!qualname) { + qualname = name; + } + module_found = __Pyx__Import_Lookup(qualname, imported_names, len_imported_names, &module); + if (likely(module_found == 1)) { + return module; + } else if (unlikely(module_found == -1)) { + return NULL; + } + empty_dict = PyDict_New(); + if (unlikely(!empty_dict)) + goto bad; + if (imported_names) { +#if CYTHON_COMPILING_IN_CPYTHON + from_list = __Pyx_PyList_FromArray(imported_names, len_imported_names); + if (unlikely(!from_list)) + goto bad; +#else + from_list = PyList_New(len_imported_names); + if (unlikely(!from_list)) goto bad; + for (Py_ssize_t i=0; i__pyx_d, level); +} + +/* FastTypeChecks */ +#if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(a, b); +} +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (cls == a || cls == b) return 1; + mro = cls->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + PyObject *base = PyTuple_GET_ITEM(mro, i); + if (base == (PyObject *)a || base == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); +} +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + if (exc_type1) { + return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + } else { + return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } +} +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); + for (i=0; itp_as_sequence && type->tp_as_sequence->sq_repeat)) { + return type->tp_as_sequence->sq_repeat(seq, mul); + } else { + return __Pyx_PySequence_Multiply_Generic(seq, mul); + } +} +#endif + +/* PyObjectFormatAndDecref */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f) { + if (unlikely(!s)) return NULL; + if (likely(PyUnicode_CheckExact(s))) return s; + return __Pyx_PyObject_FormatAndDecref(s, f); +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f) { + PyObject *result; + if (unlikely(!s)) return NULL; + result = PyObject_Format(s, f); + Py_DECREF(s); + return result; +} + +/* PyObjectFormat */ +#if CYTHON_USE_UNICODE_WRITER +static PyObject* __Pyx_PyObject_Format(PyObject* obj, PyObject* format_spec) { + int ret; + _PyUnicodeWriter writer; + if (likely(PyFloat_CheckExact(obj))) { + _PyUnicodeWriter_Init(&writer); + ret = _PyFloat_FormatAdvancedWriter( + &writer, + obj, + format_spec, 0, PyUnicode_GET_LENGTH(format_spec)); + } else if (likely(PyLong_CheckExact(obj))) { + _PyUnicodeWriter_Init(&writer); + ret = _PyLong_FormatAdvancedWriter( + &writer, + obj, + format_spec, 0, PyUnicode_GET_LENGTH(format_spec)); + } else { + return PyObject_Format(obj, format_spec); + } + if (unlikely(ret == -1)) { + _PyUnicodeWriter_Dealloc(&writer); + return NULL; + } + return _PyUnicodeWriter_Finish(&writer); +} +#endif + +/* SetItemInt */ +static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { + int r; + if (unlikely(!j)) return -1; + r = PyObject_SetItem(o, j, v); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, + int wraparound, int boundscheck, int unsafe_shared) { + CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); + if ((CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS && !__Pyx_IS_UNIQUELY_REFERENCED(o, unsafe_shared))) { + Py_INCREF(v); + return PyList_SetItem(o, n, v); + } else if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) { + PyObject* old; + Py_INCREF(v); + old = PyList_GET_ITEM(o, n); + PyList_SET_ITEM(o, n, v); + Py_DECREF(old); + return 0; + } + } else +#endif +#if CYTHON_USE_TYPE_SLOTS && !CYTHON_COMPILING_IN_PYPY + { + PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; + PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; + if (!is_list && mm && mm->mp_ass_subscript) { + int r; + PyObject *key = PyLong_FromSsize_t(i); + if (unlikely(!key)) return -1; + r = mm->mp_ass_subscript(o, key, v); + Py_DECREF(key); + return r; + } + if (is_list || likely(sm && sm->sq_ass_item)) { + if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { + Py_ssize_t l = sm->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return -1; + PyErr_Clear(); + } + } + return sm->sq_ass_item(o, i, v); + } + } +#else + if (is_list || !PyMapping_Check(o)) { + return PySequence_SetItem(o, i, v); + } +#endif + (void)wraparound; + (void)boundscheck; + return __Pyx_SetItemInt_Generic(o, PyLong_FromSsize_t(i), v); +} + +/* RaiseUnboundLocalError */ +static 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, int b_is_constant) { + long q = a / b; + long r = a - q*b; + long adapt_python = (b_is_constant ? + ((r != 0) & ((r < 0) ^ (b < 0))) : + ((r != 0) & ((r ^ b) < 0)) + ); + return q - adapt_python; +} + +/* PyObjectVectorCallKwBuilder */ +#if CYTHON_VECTORCALL +static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + (void)__Pyx_PyObject_FastCallDict; + Py_INCREF(key); + if (__Pyx_PyTuple_SET_ITEM(builder, n, key) != (0)) return -1; + args[n] = value; + return 0; +} +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + (void)__Pyx_VectorcallBuilder_AddArgStr; + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; + } + return __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n); +} +static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + PyObject *pyKey = PyUnicode_FromString(key); + if (!pyKey) return -1; + return __Pyx_VectorcallBuilder_AddArg(pyKey, value, builder, args, n); +} +#else // CYTHON_VECTORCALL +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, CYTHON_UNUSED PyObject **args, CYTHON_UNUSED int n) { + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; + } + return PyDict_SetItem(builder, key, value); +} +#endif + +/* IterFinish */ +static CYTHON_INLINE int __Pyx_IterFinish(void) { + PyObject* exc_type; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + exc_type = __Pyx_PyErr_CurrentExceptionType(); + if (unlikely(exc_type)) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) + return -1; + __Pyx_PyErr_Clear(); + return 0; + } + return 0; +} + +/* UnpackItemEndCheck */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { + if (unlikely(retval)) { + Py_DECREF(retval); + __Pyx_RaiseTooManyValuesError(expected); + return -1; + } + return __Pyx_IterFinish(); +} + +/* BufferIndexError */ +static void __Pyx_RaiseBufferIndexError(int axis) { + PyErr_Format(PyExc_IndexError, + "Out of bounds on buffer access (axis %d)", axis); +} + +/* DictGetItem */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) { + PyObject *value; + if (unlikely(__Pyx_PyDict_GetItemRef(d, key, &value) == 0)) { // no value, no error + if (unlikely(PyTuple_Check(key))) { + PyObject* args = PyTuple_Pack(1, key); + if (likely(args)) { + PyErr_SetObject(PyExc_KeyError, args); + Py_DECREF(args); + } + } else { + PyErr_SetObject(PyExc_KeyError, key); + } + } + return value; +} +#endif + +/* pybuiltin_invalid (used by pyint_simplify) */ +static void __Pyx_PyBuiltin_Invalid(PyObject *obj, const char *type_name, const char *argname) { + __Pyx_TypeName obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + if (argname) { + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected %.200s, got " __Pyx_FMT_TYPENAME ")", + argname, type_name, obj_type_name + ); + } else { + PyErr_Format(PyExc_TypeError, + "Expected %.200s, got " __Pyx_FMT_TYPENAME, + type_name, obj_type_name + ); + } + __Pyx_DECREF_TypeName(obj_type_name); +} + +/* pyint_simplify */ +static CYTHON_INLINE int __Pyx_PyInt_FromNumber(PyObject **number_var, const char *argname, int accept_none) { + PyObject *number = *number_var; + if (likely((accept_none && number == Py_None) || PyLong_CheckExact(number))) { + return 0; + } + PyObject *int_object; + if (likely(PyNumber_Check(number))) { + int_object = PyNumber_Long(number); + if (unlikely(!int_object)) goto bad; + } else { + __Pyx_PyBuiltin_Invalid(number, "int", argname); + goto bad; + } + *number_var = int_object; + Py_DECREF(number); + return 0; +bad: + *number_var = NULL; + Py_DECREF(number); + return -1; +} + +/* pep479 */ +static void __Pyx_Generator_Replace_StopIteration(int in_async_gen) { + PyObject *exc, *val, *tb, *cur_exc, *new_exc; + __Pyx_PyThreadState_declare + int is_async_stopiteration = 0; + CYTHON_MAYBE_UNUSED_VAR(in_async_gen); + __Pyx_PyThreadState_assign + cur_exc = __Pyx_PyErr_CurrentExceptionType(); + if (likely(!__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopIteration))) { + if (in_async_gen && unlikely(__Pyx_PyErr_GivenExceptionMatches(cur_exc, PyExc_StopAsyncIteration))) { + is_async_stopiteration = 1; + } else { + return; + } + } + __Pyx_GetException(&exc, &val, &tb); + Py_XDECREF(exc); + Py_XDECREF(tb); + new_exc = PyObject_CallFunction(PyExc_RuntimeError, "s", + is_async_stopiteration ? "async generator raised StopAsyncIteration" : + in_async_gen ? "async generator raised StopIteration" : + "generator raised StopIteration"); + if (!new_exc) { + Py_XDECREF(val); + return; + } + PyException_SetCause(new_exc, val); // steals ref to val + PyErr_SetObject(PyExc_RuntimeError, new_exc); + Py_DECREF(new_exc); +} + +/* PyLongBinop */ +#if !CYTHON_COMPILING_IN_PYPY +static PyObject* __Pyx_Fallback___Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, int inplace) { + return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); +} +#if CYTHON_USE_PYLONG_INTERNALS +static PyObject* __Pyx_Unpacked___Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { + CYTHON_MAYBE_UNUSED_VAR(inplace); + CYTHON_UNUSED_VAR(zerodivision_check); + const long b = intval; + long a; + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla; + if (unlikely(__Pyx_PyLong_IsZero(op1))) { + return __Pyx_NewRef(op2); + } + const int is_positive = __Pyx_PyLong_IsPos(op1); + const digit* digits = __Pyx_PyLong_Digits(op1); + const Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); + if (likely(size == 1)) { + a = (long) digits[0]; + if (!is_positive) a *= -1; + } 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])); + if (!is_positive) a *= -1; + goto calculate_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])); + if (!is_positive) lla *= -1; + goto calculate_long_long; + } + break; + 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])); + if (!is_positive) a *= -1; + goto calculate_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])); + if (!is_positive) lla *= -1; + goto calculate_long_long; + } + break; + 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])); + if (!is_positive) a *= -1; + goto calculate_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])); + if (!is_positive) lla *= -1; + goto calculate_long_long; + } + break; + } + return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + calculate_long: + { + long x; + x = a + b; + return PyLong_FromLong(x); + } + calculate_long_long: + { + PY_LONG_LONG llx; + llx = lla + llb; + return PyLong_FromLongLong(llx); + } + +} +#endif +static PyObject* __Pyx_Float___Pyx_PyLong_AddObjC(PyObject *float_val, long intval, int zerodivision_check) { + CYTHON_UNUSED_VAR(zerodivision_check); + const long b = intval; + double a = __Pyx_PyFloat_AS_DOUBLE(float_val); + double result; + + result = ((double)a) + (double)b; + return PyFloat_FromDouble(result); +} +static CYTHON_INLINE PyObject* __Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { + CYTHON_MAYBE_UNUSED_VAR(intval); + CYTHON_UNUSED_VAR(zerodivision_check); + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + return __Pyx_Unpacked___Pyx_PyLong_AddObjC(op1, op2, intval, inplace, zerodivision_check); + } + #endif + if (PyFloat_CheckExact(op1)) { + return __Pyx_Float___Pyx_PyLong_AddObjC(op1, intval, zerodivision_check); + } + return __Pyx_Fallback___Pyx_PyLong_AddObjC(op1, op2, inplace); +} +#endif + +/* PyObjectSetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE int __Pyx_PyObject_SetAttrStr(PyObject* obj, PyObject* attr_name, PyObject* value) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_setattro)) + return tp->tp_setattro(obj, attr_name, value); + return PyObject_SetAttr(obj, attr_name, value); +} +#endif + +/* PyObjectCallNoArg (used by pyfrozenset_new) */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { + PyObject *arg[2] = {NULL, NULL}; + return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* pyfrozenset_new (used by PySetContains) */ +static CYTHON_INLINE PyObject* __Pyx_PyFrozenSet_New(PyObject* it) { + if (it) { + PyObject* result; +#if CYTHON_COMPILING_IN_PYPY + PyObject* args; + args = PyTuple_Pack(1, it); + if (unlikely(!args)) + return NULL; + result = PyObject_Call((PyObject*)&PyFrozenSet_Type, args, NULL); + Py_DECREF(args); + return result; +#else + if (PyFrozenSet_CheckExact(it)) { + Py_INCREF(it); + return it; + } + result = PyFrozenSet_New(it); + if (unlikely(!result)) + return NULL; + if ((__PYX_LIMITED_VERSION_HEX >= 0x030A0000) +#if CYTHON_COMPILING_IN_LIMITED_API + || __Pyx_get_runtime_version() >= 0x030A0000 +#endif + ) + return result; + { + Py_ssize_t size = __Pyx_PySet_GET_SIZE(result); + if (likely(size > 0)) + return result; +#if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(size < 0)) { + Py_DECREF(result); + return NULL; + } +#endif + } + Py_DECREF(result); +#endif + } + return __Pyx_PyObject_CallNoArg((PyObject*) &PyFrozenSet_Type); +} + +/* PySetContains */ +static int __Pyx_PySet_ContainsUnhashable(PyObject *set, PyObject *key) { + int result = -1; + if (PySet_Check(key) && PyErr_ExceptionMatches(PyExc_TypeError)) { + PyObject *tmpkey; + PyErr_Clear(); + tmpkey = __Pyx_PyFrozenSet_New(key); + if (tmpkey != NULL) { + result = PySet_Contains(set, tmpkey); + Py_DECREF(tmpkey); + } + } + return result; +} +static CYTHON_INLINE int __Pyx_PySet_ContainsTF(PyObject* key, PyObject* set, int eq) { + int result = PySet_Contains(set, key); + if (unlikely(result < 0)) { + result = __Pyx_PySet_ContainsUnhashable(set, key); + } + return unlikely(result < 0) ? result : (result == (eq == Py_EQ)); +} + +/* set_iter */ +static CYTHON_INLINE PyObject* __Pyx_set_iterator(PyObject* iterable, int is_set, + Py_ssize_t* p_orig_length, int* p_source_is_set) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 + is_set = is_set || likely(PySet_CheckExact(iterable) || PyFrozenSet_CheckExact(iterable)); + *p_source_is_set = is_set; + if (likely(is_set)) { + *p_orig_length = PySet_Size(iterable); + Py_INCREF(iterable); + return iterable; + } +#else + CYTHON_UNUSED_VAR(is_set); + *p_source_is_set = 0; +#endif + *p_orig_length = 0; + return PyObject_GetIter(iterable); +} +static CYTHON_INLINE int __Pyx_set_iter_next( + PyObject* iter_obj, Py_ssize_t orig_length, + Py_ssize_t* ppos, PyObject **value, + int source_is_set) { + if (!CYTHON_COMPILING_IN_CPYTHON || PY_VERSION_HEX >= 0x030d0000 || unlikely(!source_is_set)) { + *value = PyIter_Next(iter_obj); + if (unlikely(!*value)) { + return __Pyx_IterFinish(); + } + CYTHON_UNUSED_VAR(orig_length); + CYTHON_UNUSED_VAR(ppos); + return 1; + } +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000 + if (unlikely(PySet_GET_SIZE(iter_obj) != orig_length)) { + PyErr_SetString( + PyExc_RuntimeError, + "set changed size during iteration"); + return -1; + } + { + Py_hash_t hash; + int ret = _PySet_NextEntry(iter_obj, ppos, value, &hash); + assert (ret != -1); + if (likely(ret)) { + Py_INCREF(*value); + return 1; + } + } +#endif + return 0; +} + +/* py_set_discard_unhashable (used by py_set_discard) */ +static int __Pyx_PySet_DiscardUnhashable(PyObject *set, PyObject *key) { + PyObject *tmpkey; + int rv; + if (likely(!PySet_Check(key) || !PyErr_ExceptionMatches(PyExc_TypeError))) + return -1; + PyErr_Clear(); + tmpkey = __Pyx_PyFrozenSet_New(key); + if (tmpkey == NULL) + return -1; + rv = PySet_Discard(set, tmpkey); + Py_DECREF(tmpkey); + return rv; +} + +/* py_set_discard */ +static CYTHON_INLINE int __Pyx_PySet_Discard(PyObject *set, PyObject *key) { + int found = PySet_Discard(set, key); + if (unlikely(found < 0)) { + found = __Pyx_PySet_DiscardUnhashable(set, key); + } + return found; +} + +/* AllocateExtensionType */ +static PyObject *__Pyx_AllocateExtensionType(PyTypeObject *t, int is_final) { + if (is_final || likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + allocfunc alloc_func = __Pyx_PyType_GetSlot(t, tp_alloc, allocfunc); + return alloc_func(t, 0); + } else { + newfunc tp_new = __Pyx_PyType_TryGetSlot(&PyBaseObject_Type, tp_new, newfunc); + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + if (!tp_new) { + PyObject *new_str = PyUnicode_FromString("__new__"); + if (likely(new_str)) { + PyObject *o = PyObject_CallMethodObjArgs((PyObject *)&PyBaseObject_Type, new_str, t, NULL); + Py_DECREF(new_str); + return o; + } else + return NULL; + } else + #endif + return tp_new(t, __pyx_mstate_global->__pyx_empty_tuple, 0); + } +} + +/* CallTypeTraverse */ +#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) +#else +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg) { + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000 + if (__Pyx_get_runtime_version() < 0x03090000) return 0; + #endif + if (!always_call) { + PyTypeObject *base = __Pyx_PyObject_GetSlot(o, tp_base, PyTypeObject*); + unsigned long flags = PyType_GetFlags(base); + if (flags & Py_TPFLAGS_HEAPTYPE) { + return 0; + } + } + Py_VISIT((PyObject*)Py_TYPE(o)); + return 0; +} +#endif + +/* LimitedApiGetTypeDict (used by SetItemOnTypeDict) */ +#if CYTHON_COMPILING_IN_LIMITED_API +static Py_ssize_t __Pyx_GetTypeDictOffset(void) { + PyObject *tp_dictoffset_o; + Py_ssize_t tp_dictoffset; + tp_dictoffset_o = PyObject_GetAttrString((PyObject*)(&PyType_Type), "__dictoffset__"); + if (unlikely(!tp_dictoffset_o)) return -1; + tp_dictoffset = PyLong_AsSsize_t(tp_dictoffset_o); + Py_DECREF(tp_dictoffset_o); + if (unlikely(tp_dictoffset == 0)) { + PyErr_SetString( + PyExc_TypeError, + "'type' doesn't have a dictoffset"); + return -1; + } else if (unlikely(tp_dictoffset < 0)) { + PyErr_SetString( + PyExc_TypeError, + "'type' has an unexpected negative dictoffset. " + "Please report this as Cython bug"); + return -1; + } + return tp_dictoffset; +} +static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp) { + static Py_ssize_t tp_dictoffset = 0; + if (unlikely(tp_dictoffset == 0)) { + tp_dictoffset = __Pyx_GetTypeDictOffset(); + if (unlikely(tp_dictoffset == -1 && PyErr_Occurred())) { + tp_dictoffset = 0; // try again next time? + return NULL; + } + } + return *(PyObject**)((char*)tp + tp_dictoffset); +} +#endif + +/* SetItemOnTypeDict (used by FixUpExtensionType) */ +static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v) { + int result; + PyObject *tp_dict; +#if CYTHON_COMPILING_IN_LIMITED_API + tp_dict = __Pyx_GetTypeDict(tp); + if (unlikely(!tp_dict)) return -1; +#else + tp_dict = tp->tp_dict; +#endif + result = PyDict_SetItem(tp_dict, k, v); + if (likely(!result)) { + PyType_Modified(tp); + if (unlikely(PyObject_HasAttr(v, __pyx_mstate_global->__pyx_n_u_set_name))) { + PyObject *setNameResult = PyObject_CallMethodObjArgs(v, __pyx_mstate_global->__pyx_n_u_set_name, (PyObject *) tp, k, NULL); + if (!setNameResult) return -1; + Py_DECREF(setNameResult); + } + } + return result; +} + +/* FixUpExtensionType */ +static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { +#if __PYX_LIMITED_VERSION_HEX > 0x030900B1 + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); +#else + const PyType_Slot *slot = spec->slots; + int changed = 0; +#if !CYTHON_COMPILING_IN_LIMITED_API + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { +#if !CYTHON_COMPILING_IN_CPYTHON + const +#endif // !CYTHON_COMPILING_IN_CPYTHON) + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { + if (strcmp(memb->name, "__weaklistoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_weaklistoffset = memb->offset; + changed = 1; + } + else if (strcmp(memb->name, "__dictoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_dictoffset = memb->offset; + changed = 1; + } +#if CYTHON_METH_FASTCALL + else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_vectorcall_offset = memb->offset; + changed = 1; + } +#endif // CYTHON_METH_FASTCALL +#if !CYTHON_COMPILING_IN_PYPY + else if (strcmp(memb->name, "__module__") == 0) { + PyObject *descr; + assert(memb->type == T_OBJECT); + assert(memb->flags == 0 || memb->flags == READONLY); + descr = PyDescr_NewMember(type, memb); + if (unlikely(!descr)) + return -1; + int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr); + Py_DECREF(descr); + if (unlikely(set_item_result < 0)) { + return -1; + } + changed = 1; + } +#endif // !CYTHON_COMPILING_IN_PYPY + } + memb++; + } + } +#endif // !CYTHON_COMPILING_IN_LIMITED_API +#if !CYTHON_COMPILING_IN_PYPY + slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_getset) + slot++; + if (slot && slot->slot == Py_tp_getset) { + PyGetSetDef *getset = (PyGetSetDef*) slot->pfunc; + while (getset && getset->name) { + if (getset->name[0] == '_' && getset->name[1] == '_' && strcmp(getset->name, "__module__") == 0) { + PyObject *descr = PyDescr_NewGetSet(type, getset); + if (unlikely(!descr)) + return -1; + #if CYTHON_COMPILING_IN_LIMITED_API + PyObject *pyname = PyUnicode_FromString(getset->name); + if (unlikely(!pyname)) { + Py_DECREF(descr); + return -1; + } + int set_item_result = __Pyx_SetItemOnTypeDict(type, pyname, descr); + Py_DECREF(pyname); + #else + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); + int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr); + #endif + Py_DECREF(descr); + if (unlikely(set_item_result < 0)) { + return -1; + } + changed = 1; + } + ++getset; + } + } +#else + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); +#endif // !CYTHON_COMPILING_IN_PYPY + if (changed) + PyType_Modified(type); +#endif // PY_VERSION_HEX > 0x030900B1 + return 0; +} + +/* PyObjectGetMethod (used by PyObjectCallMethod0) */ +#if !(CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))) +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { + PyObject *attr; +#if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP + __Pyx_TypeName type_name; + PyTypeObject *tp = Py_TYPE(obj); + PyObject *descr; + descrgetfunc f = NULL; + PyObject **dictptr, *dict; + int meth_found = 0; + assert (*method == NULL); + if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; + } + if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { + return 0; + } + descr = _PyType_Lookup(tp, name); + if (likely(descr != NULL)) { + Py_INCREF(descr); +#if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR + if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) +#else + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) + #endif +#endif + { + meth_found = 1; + } else { + f = Py_TYPE(descr)->tp_descr_get; + if (f != NULL && PyDescr_IsData(descr)) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + } + } + dictptr = _PyObject_GetDictPtr(obj); + if (dictptr != NULL && (dict = *dictptr) != NULL) { + Py_INCREF(dict); + attr = __Pyx_PyDict_GetItemStr(dict, name); + if (attr != NULL) { + Py_INCREF(attr); + Py_DECREF(dict); + Py_XDECREF(descr); + goto try_unpack; + } + Py_DECREF(dict); + } + if (meth_found) { + *method = descr; + return 1; + } + if (f != NULL) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + if (likely(descr != NULL)) { + *method = descr; + return 0; + } + type_name = __Pyx_PyType_GetFullyQualifiedName(tp); + PyErr_Format(PyExc_AttributeError, + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); + __Pyx_DECREF_TypeName(type_name); + return 0; +#else + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; +#endif +try_unpack: +#if CYTHON_UNPACK_METHODS + if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { + PyObject *function = PyMethod_GET_FUNCTION(attr); + Py_INCREF(function); + Py_DECREF(attr); + *method = function; + return 1; + } +#endif + *method = attr; + return 0; +} +#endif + +/* PyObjectCallMethod0 (used by PyType_Ready) */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { +#if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000)) + PyObject *args[1] = {obj}; + (void) __Pyx_PyObject_CallOneArg; + (void) __Pyx_PyObject_CallNoArg; + return PyObject_VectorcallMethod(method_name, args, 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +#else + PyObject *method = NULL, *result = NULL; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_CallOneArg(method, obj); + Py_DECREF(method); + return result; + } + if (unlikely(!method)) goto bad; + result = __Pyx_PyObject_CallNoArg(method); + Py_DECREF(method); +bad: + return result; +#endif +} + +/* ValidateBasesTuple (used by PyType_Ready) */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { + Py_ssize_t i, n; +#if CYTHON_ASSUME_SAFE_SIZE + n = PyTuple_GET_SIZE(bases); +#else + n = PyTuple_Size(bases); + if (unlikely(n < 0)) return -1; +#endif + for (i = 1; i < n; i++) + { + PyTypeObject *b; +#if CYTHON_AVOID_BORROWED_REFS + PyObject *b0 = PySequence_GetItem(bases, i); + if (!b0) return -1; +#elif CYTHON_ASSUME_SAFE_MACROS + PyObject *b0 = PyTuple_GET_ITEM(bases, i); +#else + PyObject *b0 = PyTuple_GetItem(bases, i); + if (!b0) return -1; +#endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetFullyQualifiedName(b); + PyErr_Format(PyExc_TypeError, + "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); + __Pyx_DECREF_TypeName(b_name); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + if (dictoffset == 0) + { + Py_ssize_t b_dictoffset = 0; +#if CYTHON_USE_TYPE_SLOTS + b_dictoffset = b->tp_dictoffset; +#else + PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); + if (!py_b_dictoffset) goto dictoffset_return; + b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); + Py_DECREF(py_b_dictoffset); + if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; +#endif + if (b_dictoffset) { + { + __Pyx_TypeName b_name = __Pyx_PyType_GetFullyQualifiedName(b); + PyErr_Format(PyExc_TypeError, + "extension type '%.200s' has no __dict__ slot, " + "but base type '" __Pyx_FMT_TYPENAME "' has: " + "either add 'cdef dict __dict__' to the extension type " + "or add '__slots__ = [...]' to the base type", + type_name, b_name); + __Pyx_DECREF_TypeName(b_name); + } +#if !CYTHON_USE_TYPE_SLOTS + dictoffset_return: +#endif +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + return -1; + } + } +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); +#endif + } + return 0; +} +#endif + +/* PyType_Ready */ +CYTHON_UNUSED static int __Pyx_PyType_HasMultipleInheritance(PyTypeObject *t) { + while (t) { + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases) { + return 1; + } + t = __Pyx_PyType_GetSlot(t, tp_base, PyTypeObject*); + } + return 0; +} +static int __Pyx_PyType_Ready(PyTypeObject *t) { +#if CYTHON_USE_TYPE_SPECS || !CYTHON_COMPILING_IN_CPYTHON || defined(PYSTON_MAJOR_VERSION) + (void)__Pyx_PyObject_CallMethod0; +#if CYTHON_USE_TYPE_SPECS + (void)__Pyx_validate_bases_tuple; +#endif + return PyType_Ready(t); +#else + int r; + if (!__Pyx_PyType_HasMultipleInheritance(t)) { + return PyType_Ready(t); + } + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) + return -1; +#if !defined(PYSTON_MAJOR_VERSION) + { + int gc_was_enabled; + #if PY_VERSION_HEX >= 0x030A00b1 + gc_was_enabled = PyGC_Disable(); + (void)__Pyx_PyObject_CallMethod0; + #else + PyObject *ret, *py_status; + PyObject *gc = NULL; + #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) &&\ + !CYTHON_COMPILING_IN_GRAAL + gc = PyImport_GetModule(__pyx_mstate_global->__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_mstate_global->__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_isenabled); + if (unlikely(!py_status)) { + Py_DECREF(gc); + return -1; + } + gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); + Py_DECREF(py_status); + if (gc_was_enabled > 0) { + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_disable); + if (unlikely(!ret)) { + Py_DECREF(gc); + return -1; + } + Py_DECREF(ret); + } else if (unlikely(gc_was_enabled == -1)) { + Py_DECREF(gc); + return -1; + } + #endif + t->tp_flags |= Py_TPFLAGS_HEAPTYPE; +#if PY_VERSION_HEX >= 0x030A0000 + t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; +#endif +#else + (void)__Pyx_PyObject_CallMethod0; +#endif + r = PyType_Ready(t); +#if !defined(PYSTON_MAJOR_VERSION) + t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; + #if PY_VERSION_HEX >= 0x030A00b1 + if (gc_was_enabled) + PyGC_Enable(); + #else + if (gc_was_enabled) { + PyObject *tp, *v, *tb; + PyErr_Fetch(&tp, &v, &tb); + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_enable); + if (likely(ret || r == -1)) { + Py_XDECREF(ret); + PyErr_Restore(tp, v, tb); + } else { + Py_XDECREF(tp); + Py_XDECREF(v); + Py_XDECREF(tb); + r = -1; + } + } + Py_DECREF(gc); + #endif + } +#endif + return r; +#endif +} + +/* SetVTable */ +static int __Pyx_SetVtable(PyTypeObject *type, void *vtable) { + PyObject *ob = PyCapsule_New(vtable, 0, 0); + if (unlikely(!ob)) + goto bad; +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(PyObject_SetAttr((PyObject *) type, __pyx_mstate_global->__pyx_n_u_pyx_vtable, ob) < 0)) +#else + if (unlikely(PyDict_SetItem(type->tp_dict, __pyx_mstate_global->__pyx_n_u_pyx_vtable, ob) < 0)) +#endif + goto bad; + Py_DECREF(ob); + return 0; +bad: + Py_XDECREF(ob); + return -1; +} + +/* GetVTable (used by MergeVTables) */ +static void* __Pyx_GetVtable(PyTypeObject *type) { + void* ptr; +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_mstate_global->__pyx_n_u_pyx_vtable); +#else + PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_mstate_global->__pyx_n_u_pyx_vtable); +#endif + if (!ob) + goto bad; + ptr = PyCapsule_GetPointer(ob, 0); + if (!ptr && !PyErr_Occurred()) + PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); + Py_DECREF(ob); + return ptr; +bad: + Py_XDECREF(ob); + return NULL; +} + +/* MergeVTables */ +static int __Pyx_MergeVtables(PyTypeObject *type) { + int i=0; + Py_ssize_t size; + void** base_vtables; + __Pyx_TypeName tp_base_name = NULL; + __Pyx_TypeName base_name = NULL; + void* unknown = (void*)-1; + PyObject* bases = __Pyx_PyType_GetSlot(type, tp_bases, PyObject*); + int base_depth = 0; + { + PyTypeObject* base = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + while (base) { + base_depth += 1; + base = __Pyx_PyType_GetSlot(base, tp_base, PyTypeObject*); + } + } + base_vtables = (void**) PyMem_Malloc(sizeof(void*) * (size_t)(base_depth + 1)); + base_vtables[0] = unknown; +#if CYTHON_COMPILING_IN_LIMITED_API + size = PyTuple_Size(bases); + if (size < 0) goto other_failure; +#else + size = PyTuple_GET_SIZE(bases); +#endif + for (i = 1; i < size; i++) { + PyObject *basei; + void* base_vtable; +#if CYTHON_AVOID_BORROWED_REFS + basei = PySequence_GetItem(bases, i); + if (unlikely(!basei)) goto other_failure; +#elif !CYTHON_ASSUME_SAFE_MACROS + basei = PyTuple_GetItem(bases, i); + if (unlikely(!basei)) goto other_failure; +#else + basei = PyTuple_GET_ITEM(bases, i); +#endif + base_vtable = __Pyx_GetVtable((PyTypeObject*)basei); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(basei); +#endif + if (base_vtable != NULL) { + int j; + PyTypeObject* base = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + for (j = 0; j < base_depth; j++) { + if (base_vtables[j] == unknown) { + base_vtables[j] = __Pyx_GetVtable(base); + base_vtables[j + 1] = unknown; + } + if (base_vtables[j] == base_vtable) { + break; + } else if (base_vtables[j] == NULL) { + goto bad; + } + base = __Pyx_PyType_GetSlot(base, tp_base, PyTypeObject*); + } + } + } + PyErr_Clear(); + PyMem_Free(base_vtables); + return 0; +bad: + { + PyTypeObject* basei = NULL; + PyTypeObject* tp_base = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + tp_base_name = __Pyx_PyType_GetFullyQualifiedName(tp_base); +#if CYTHON_AVOID_BORROWED_REFS + basei = (PyTypeObject*)PySequence_GetItem(bases, i); + if (unlikely(!basei)) goto really_bad; +#elif !CYTHON_ASSUME_SAFE_MACROS + basei = (PyTypeObject*)PyTuple_GetItem(bases, i); + if (unlikely(!basei)) goto really_bad; +#else + basei = (PyTypeObject*)PyTuple_GET_ITEM(bases, i); +#endif + base_name = __Pyx_PyType_GetFullyQualifiedName(basei); +#if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(basei); +#endif + } + PyErr_Format(PyExc_TypeError, + "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base_name, base_name); +#if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS +really_bad: // bad has failed! +#endif + __Pyx_DECREF_TypeName(tp_base_name); + __Pyx_DECREF_TypeName(base_name); +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS +other_failure: +#endif + PyMem_Free(base_vtables); + return -1; +} + +/* DelItemOnTypeDict (used by SetupReduce) */ +static int __Pyx__DelItemOnTypeDict(PyTypeObject *tp, PyObject *k) { + int result; + PyObject *tp_dict; +#if CYTHON_COMPILING_IN_LIMITED_API + tp_dict = __Pyx_GetTypeDict(tp); + if (unlikely(!tp_dict)) return -1; +#else + tp_dict = tp->tp_dict; +#endif + result = PyDict_DelItem(tp_dict, k); + if (likely(!result)) PyType_Modified(tp); + return result; +} + +/* SetupReduce */ +static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_mstate_global->__pyx_n_u_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_mstate_global->__pyx_n_u_getstate); +#else + getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_getstate); + if (!getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } +#endif + if (getstate) { +#if CYTHON_USE_PYTYPE_LOOKUP + object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_getstate); +#else + object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_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_mstate_global->__pyx_n_u_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#else + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; +#endif + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_mstate_global->__pyx_n_u_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_mstate_global->__pyx_n_u_reduce); if (!object_reduce) goto __PYX_BAD; +#else + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce); if (!object_reduce) goto __PYX_BAD; +#endif + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_mstate_global->__pyx_n_u_reduce); if (unlikely(!reduce)) goto __PYX_BAD; + if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_mstate_global->__pyx_n_u_reduce_cython)) { + reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_reduce_cython); + if (likely(reduce_cython)) { + ret = __Pyx_SetItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = __Pyx_DelItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (reduce == object_reduce || PyErr_Occurred()) { + goto __PYX_BAD; + } + setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_setstate); + if (!setstate) PyErr_Clear(); + if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_mstate_global->__pyx_n_u_setstate_cython)) { + setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_setstate_cython); + if (likely(setstate_cython)) { + ret = __Pyx_SetItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = __Pyx_DelItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_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()) { + __Pyx_TypeName type_obj_name = + __Pyx_PyType_GetFullyQualifiedName((PyTypeObject*)type_obj); + PyErr_Format(PyExc_RuntimeError, + "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); + __Pyx_DECREF_TypeName(type_obj_name); + } + ret = -1; +__PYX_GOOD: +#if !CYTHON_USE_PYTYPE_LOOKUP + Py_XDECREF(object_reduce); + Py_XDECREF(object_reduce_ex); + Py_XDECREF(object_getstate); + Py_XDECREF(getstate); +#endif + Py_XDECREF(reduce); + Py_XDECREF(reduce_ex); + Py_XDECREF(reduce_cython); + Py_XDECREF(setstate); + Py_XDECREF(setstate_cython); + return ret; +} + +/* TypeImport */ +#ifndef __PYX_HAVE_RT_ImportType_3_2_9 +#define __PYX_HAVE_RT_ImportType_3_2_9 +static PyTypeObject *__Pyx_ImportType_3_2_9(PyObject *module, const char *module_name, const char *class_name, + size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_2_9 check_size) +{ + PyObject *result = 0; + Py_ssize_t basicsize; + Py_ssize_t itemsize; +#if defined(Py_LIMITED_API) || (defined(CYTHON_COMPILING_IN_LIMITED_API) && CYTHON_COMPILING_IN_LIMITED_API) + PyObject *py_basicsize; + PyObject *py_itemsize; +#endif + result = PyObject_GetAttrString(module, class_name); + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } +#if !( defined(Py_LIMITED_API) || (defined(CYTHON_COMPILING_IN_LIMITED_API) && CYTHON_COMPILING_IN_LIMITED_API) ) + basicsize = ((PyTypeObject *)result)->tp_basicsize; + itemsize = ((PyTypeObject *)result)->tp_itemsize; +#else + if (size == 0) { + return (PyTypeObject *)result; + } + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; + py_itemsize = PyObject_GetAttrString(result, "__itemsize__"); + if (!py_itemsize) + goto bad; + itemsize = PyLong_AsSsize_t(py_itemsize); + Py_DECREF(py_itemsize); + py_itemsize = 0; + if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; +#endif + if (itemsize) { + if (size % alignment) { + alignment = size % alignment; + } + if (itemsize < (Py_ssize_t)alignment) + itemsize = (Py_ssize_t)alignment; + } + if ((size_t)(basicsize + itemsize) < size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize+itemsize); + goto bad; + } + if (check_size == __Pyx_ImportType_CheckSize_Error_3_2_9 && + ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd-%zd from PyObject", + module_name, class_name, size, basicsize, basicsize+itemsize); + goto bad; + } + else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_2_9 && (size_t)basicsize > size) { + if (PyErr_WarnFormat(NULL, 0, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize) < 0) { + goto bad; + } + } + return (PyTypeObject *)result; +bad: + Py_XDECREF(result); + return NULL; +} +#endif + +/* dict_setdefault (used by FetchCommonType) */ +static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value) { + PyObject* value; +#if __PYX_LIMITED_VERSION_HEX >= 0x030F0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4) + PyDict_SetDefaultRef(d, key, default_value, &value); +#elif CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + PyObject *args[] = {d, key, default_value}; + value = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_n_u_setdefault, args, 3 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); +#elif CYTHON_COMPILING_IN_LIMITED_API + value = PyObject_CallMethodObjArgs(d, __pyx_mstate_global->__pyx_n_u_setdefault, key, default_value, NULL); +#else + value = PyDict_SetDefault(d, key, default_value); + if (unlikely(!value)) return NULL; + Py_INCREF(value); +#endif + return value; +} + +/* AddModuleRef (used by FetchSharedCythonModule) */ +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + static PyObject *__Pyx_PyImport_AddModuleObjectRef(PyObject *name) { + PyObject *module_dict = PyImport_GetModuleDict(); + PyObject *m; + if (PyMapping_GetOptionalItem(module_dict, name, &m) < 0) { + return NULL; + } + if (m != NULL && PyModule_Check(m)) { + return m; + } + Py_XDECREF(m); + m = PyModule_NewObject(name); + if (m == NULL) + return NULL; + if (PyDict_CheckExact(module_dict)) { + PyObject *new_m; + (void)PyDict_SetDefaultRef(module_dict, name, m, &new_m); + Py_DECREF(m); + return new_m; + } else { + if (PyObject_SetItem(module_dict, name, m) != 0) { + Py_DECREF(m); + return NULL; + } + return m; + } + } + static PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *py_name = PyUnicode_FromString(name); + if (!py_name) return NULL; + PyObject *module = __Pyx_PyImport_AddModuleObjectRef(py_name); + Py_DECREF(py_name); + return module; + } +#elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#else + static PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } +#endif + +/* FetchSharedCythonModule (used by FetchCommonType) */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void) { + return __Pyx_PyImport_AddModuleRef(__PYX_ABI_MODULE_NAME); +} + +/* FetchCommonType (used by CommonTypesMetaclass) */ +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 +static PyObject* __Pyx_PyType_FromMetaclass(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *result = __Pyx_PyType_FromModuleAndSpec(module, spec, bases); + if (result && metaclass) { + PyObject *old_tp = (PyObject*)Py_TYPE(result); + Py_INCREF((PyObject*)metaclass); +#if __PYX_LIMITED_VERSION_HEX >= 0x03090000 + Py_SET_TYPE(result, metaclass); +#else + result->ob_type = metaclass; +#endif + Py_DECREF(old_tp); + } + return result; +} +#else +#define __Pyx_PyType_FromMetaclass(me, mo, s, b) PyType_FromMetaclass(me, mo, s, b) +#endif +static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t expected_basicsize) { + Py_ssize_t basicsize; + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; + } + if (expected_basicsize == 0) { + return 0; // size is inherited, nothing useful to check + } +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) return -1; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = NULL; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) return -1; +#else + basicsize = ((PyTypeObject*) cached_type)->tp_basicsize; +#endif + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; +} +static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module = NULL, *cached_type = NULL, *abi_module_dict, *new_cached_type, *py_object_name; + int get_item_ref_result; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + py_object_name = PyUnicode_FromString(object_name); + if (!py_object_name) return NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) goto done; + abi_module_dict = PyModule_GetDict(abi_module); + if (!abi_module_dict) goto done; + get_item_ref_result = __Pyx_PyDict_GetItemRef(abi_module_dict, py_object_name, &cached_type); + if (get_item_ref_result == 1) { + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } else if (unlikely(get_item_ref_result == -1)) { + goto bad; + } + cached_type = __Pyx_PyType_FromMetaclass( + metaclass, + CYTHON_USE_MODULE_STATE ? module : abi_module, + spec, bases); + if (unlikely(!cached_type)) goto bad; + if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; + new_cached_type = __Pyx_PyDict_SetDefault(abi_module_dict, py_object_name, cached_type); + if (unlikely(new_cached_type != cached_type)) { + if (unlikely(!new_cached_type)) goto bad; + Py_DECREF(cached_type); + cached_type = new_cached_type; + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } else { + Py_DECREF(new_cached_type); + } +done: + Py_XDECREF(abi_module); + Py_DECREF(py_object_name); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; +bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; +} + +/* CommonTypesMetaclass (used by CythonFunctionShared) */ +static PyObject* __pyx_CommonTypesMetaclass_get_module(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED void* context) { + return PyUnicode_FromString(__PYX_ABI_MODULE_NAME); +} +#if __PYX_LIMITED_VERSION_HEX < 0x030A0000 +static PyObject* __pyx_CommonTypesMetaclass_call(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *args, CYTHON_UNUSED PyObject *kwds) { + PyErr_SetString(PyExc_TypeError, "Cannot instantiate Cython internal types"); + return NULL; +} +static int __pyx_CommonTypesMetaclass_setattr(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *attr, CYTHON_UNUSED PyObject *value) { + PyErr_SetString(PyExc_TypeError, "Cython internal types are immutable"); + return -1; +} +#endif +static PyGetSetDef __pyx_CommonTypesMetaclass_getset[] = { + {"__module__", __pyx_CommonTypesMetaclass_get_module, NULL, NULL, NULL}, + {0, 0, 0, 0, 0} +}; +static PyType_Slot __pyx_CommonTypesMetaclass_slots[] = { + {Py_tp_getset, (void *)__pyx_CommonTypesMetaclass_getset}, + #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 + {Py_tp_call, (void*)__pyx_CommonTypesMetaclass_call}, + {Py_tp_new, (void*)__pyx_CommonTypesMetaclass_call}, + {Py_tp_setattro, (void*)__pyx_CommonTypesMetaclass_setattr}, + #endif + {0, 0} +}; +static PyType_Spec __pyx_CommonTypesMetaclass_spec = { + __PYX_TYPE_MODULE_PREFIX "_common_types_metatype", + 0, + 0, + Py_TPFLAGS_IMMUTABLETYPE | + Py_TPFLAGS_DISALLOW_INSTANTIATION | + Py_TPFLAGS_DEFAULT, + __pyx_CommonTypesMetaclass_slots +}; +static int __pyx_CommonTypesMetaclass_init(PyObject *module) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + PyObject *bases = PyTuple_Pack(1, &PyType_Type); + if (unlikely(!bases)) { + return -1; + } + mstate->__pyx_CommonTypesMetaclassType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CommonTypesMetaclass_spec, bases); + Py_DECREF(bases); + if (unlikely(mstate->__pyx_CommonTypesMetaclassType == NULL)) { + return -1; + } + return 0; +} + +/* PyMethodNew (used by CythonFunctionShared) */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *result; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + #if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + { + PyObject *args[] = {func, self}; + result = PyObject_Vectorcall(__pyx_mstate_global->__Pyx_CachedMethodType, args, 2, NULL); + } + #else + result = PyObject_CallFunctionObjArgs(__pyx_mstate_global->__Pyx_CachedMethodType, func, self, NULL); + #endif + return result; +} +#else +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + return PyMethod_New(func, self); +} +#endif + +/* PyVectorcallFastCallDict (used by CythonFunctionShared) */ +#if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL +static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + PyObject *res = NULL; + PyObject *kwnames; + PyObject **newargs; + PyObject **kwvalues; + Py_ssize_t i; + #if CYTHON_AVOID_BORROWED_REFS + PyObject *pos; + #else + Py_ssize_t pos; + #endif + size_t j; + PyObject *key, *value; + unsigned long keys_are_strings; + #if !CYTHON_ASSUME_SAFE_SIZE + Py_ssize_t nkw = PyDict_Size(kw); + if (unlikely(nkw == -1)) return NULL; + #else + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + #endif + newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); + if (unlikely(newargs == NULL)) { + PyErr_NoMemory(); + return NULL; + } + for (j = 0; j < nargs; j++) newargs[j] = args[j]; + kwnames = PyTuple_New(nkw); + if (unlikely(kwnames == NULL)) { + PyMem_Free(newargs); + return NULL; + } + kwvalues = newargs + nargs; + pos = 0; + i = 0; + keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; + while (__Pyx_PyDict_NextRef(kw, &pos, &key, &value)) { + keys_are_strings &= + #if CYTHON_COMPILING_IN_LIMITED_API + PyType_GetFlags(Py_TYPE(key)); + #else + Py_TYPE(key)->tp_flags; + #endif + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(PyTuple_SetItem(kwnames, i, key) < 0)) goto cleanup; + #else + PyTuple_SET_ITEM(kwnames, i, key); + #endif + kwvalues[i] = value; + i++; + } + if (unlikely(!keys_are_strings)) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + goto cleanup; + } + res = vc(func, newargs, nargs, kwnames); +cleanup: + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(pos); + #endif + Py_DECREF(kwnames); + for (i = 0; i < nkw; i++) + Py_DECREF(kwvalues[i]); + PyMem_Free(newargs); + return res; +} +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) +{ + Py_ssize_t kw_size = + likely(kw == NULL) ? + 0 : +#if !CYTHON_ASSUME_SAFE_SIZE + PyDict_Size(kw); +#else + PyDict_GET_SIZE(kw); +#endif + if (kw_size == 0) { + return vc(func, args, nargs, NULL); + } +#if !CYTHON_ASSUME_SAFE_SIZE + else if (unlikely(kw_size == -1)) { + return NULL; + } +#endif + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); +} +#endif + +/* CythonFunctionShared (used by CythonFunction) */ +#if CYTHON_COMPILING_IN_LIMITED_API +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunctionNoMethod(PyObject *func, void (*cfunc)(void)) { + if (__Pyx_CyFunction_Check(func)) { + return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; + } else if (PyCFunction_Check(func)) { + return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; + } + return 0; +} +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if ((PyObject*)Py_TYPE(func) == __pyx_mstate_global->__Pyx_CachedMethodType) { + int result; + PyObject *newFunc = PyObject_GetAttr(func, __pyx_mstate_global->__pyx_n_u_func); + if (unlikely(!newFunc)) { + PyErr_Clear(); // It's only an optimization, so don't throw an error + return 0; + } + result = __Pyx__IsSameCyOrCFunctionNoMethod(newFunc, cfunc); + Py_DECREF(newFunc); + return result; + } + return __Pyx__IsSameCyOrCFunctionNoMethod(func, cfunc); +} +#else +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if (PyMethod_Check(func)) { + func = PyMethod_GET_FUNCTION(func); + } + return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +} +#endif +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + __Pyx_Py_XDECREF_SET( + __Pyx_CyFunction_GetClassObj(f), + ((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#else + __Pyx_Py_XDECREF_SET( + ((PyCMethodObject *) (f))->mm_class, + (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); +#endif +} +static PyObject * +__Pyx_CyFunction_get_doc_locked(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_doc == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); + if (unlikely(!op->func_doc)) return NULL; +#else + if (((PyCFunctionObject*)op)->m_ml->ml_doc) { + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } +#endif + } + Py_INCREF(op->func_doc); + return op->func_doc; +} +static PyObject * +__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) { + PyObject *result; + CYTHON_UNUSED_VAR(closure); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_doc_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_doc, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_name_locked(__pyx_CyFunctionObject *op) +{ + if (unlikely(op->func_name == NULL)) { +#if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); +#else + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); +#endif + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; +} +static PyObject * +__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) +{ + PyObject *result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_name_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_name, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + PyObject *result; + __Pyx_BEGIN_CRITICAL_SECTION(op); + Py_INCREF(op->func_qualname); + result = op->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 +static PyObject * +__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; +} +#endif +static PyObject * +__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_globals); + return op->func_globals; +} +static PyObject * +__Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) +{ + CYTHON_UNUSED_VAR(op); + CYTHON_UNUSED_VAR(context); + Py_INCREF(Py_None); + return Py_None; +} +static PyObject * +__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) +{ + PyObject* result = (op->func_code) ? op->func_code : Py_None; + CYTHON_UNUSED_VAR(context); + Py_INCREF(result); + return result; +} +static int +__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; +} +static int +__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_defaults_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_tuple; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_defaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int +__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_kwdict; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_kwdefaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static int __Pyx_CyFunction_set_annotate_in_dict_if_exists(PyObject *op_in, PyObject *value); +static int +__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value || value == Py_None) { + value = NULL; + } else if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_annotations, value); + __Pyx_END_CRITICAL_SECTION(); + if (unlikely(__Pyx_CyFunction_set_annotate_in_dict_if_exists((PyObject*) op, Py_None) < 0)) return -1; + return 0; +} +static int +__Pyx_CyFunction_get_dict_if_exists(PyObject *op_in, PyObject **dict) { + /* Return 1 if the function dict exists, 0 otherwise. This cannot fail: + * _PyObject_GetDictPtr() may clear errors internally, but never reports them. */ +#if CYTHON_COMPILING_IN_PYPY + *dict = PyObject_GenericGetDict(op_in, NULL); +#elif CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030C0000 + *dict = ((__pyx_CyFunctionObject*) op_in)->func_dict; +#else + PyObject **dictptr = _PyObject_GetDictPtr(op_in); + *dict = likely(dictptr) ? *dictptr : NULL; +#endif + return *dict ? 1 : 0; +} +static int +__Pyx_CyFunction_get_annotate_from_dict_if_exists(PyObject *op_in, PyObject **annotate) { + PyObject *dict; + int dict_found; + *annotate = NULL; + dict_found = __Pyx_CyFunction_get_dict_if_exists(op_in, &dict); + if (!dict_found) return 0; + return __Pyx_PyDict_GetItemRef(dict, __pyx_mstate_global->__pyx_n_u_annotate, annotate); +} +static int +__Pyx_CyFunction_set_annotate_in_dict_if_exists(PyObject *op_in, PyObject *value) { + PyObject *dict; + int dict_found; + dict_found = __Pyx_CyFunction_get_dict_if_exists(op_in, &dict); + if (!dict_found) return 0; + return PyDict_SetItem(dict, __pyx_mstate_global->__pyx_n_u_annotate, value); +} +static int +__Pyx_CyFunction_set_annotate_in_dict(PyObject *op_in, PyObject *value) { + PyObject *dict; + int result; +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + dict = __Pyx_CyFunction_get_dict((__pyx_CyFunctionObject*) op_in, NULL); +#else + dict = PyObject_GenericGetDict(op_in, NULL); +#endif + if (unlikely(!dict)) return -1; + result = PyDict_SetItem(dict, __pyx_mstate_global->__pyx_n_u_annotate, value); + Py_DECREF(dict); + return result; +} +static PyObject * +__Pyx_CyFunction_get_annotations_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->func_annotations; + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; +} +static PyObject * +__Pyx_CyFunction_get_annotations(PyObject *op_in, void *context) { + PyObject *annotate = NULL; + PyObject *result = NULL; + __pyx_CyFunctionObject *op = (__pyx_CyFunctionObject*) op_in; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + result = __Pyx_XNewRef(op->func_annotations); + __Pyx_END_CRITICAL_SECTION(); + if (result) return result; + if (unlikely(__Pyx_CyFunction_get_annotate_from_dict_if_exists(op_in, &annotate) < 0)) return NULL; + if (!annotate || annotate == Py_None) { + Py_XDECREF(annotate); + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + result = __Pyx_CyFunction_get_annotations_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; + } + PyObject *format = PyLong_FromLong(1L); // annotationlib.Format.VALUE + if (likely(format)) { + result = __Pyx_PyObject_CallOneArg(annotate, format); + Py_DECREF(format); + } + Py_DECREF(annotate); + if (unlikely(!result)) return NULL; + if (unlikely(!PyDict_Check(result))) { + PyErr_SetString(PyExc_TypeError, "__annotate__ must return a dict"); + Py_DECREF(result); + return NULL; + } + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + __Pyx_Py_XDECREF_SET(op->func_annotations, __Pyx_NewRef(result)); + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static PyObject *__Pyx_CyFunction_annotate_impl(PyObject *self, PyObject *args) { + CYTHON_UNUSED_VAR(args); + if (unlikely(!self)) { + PyErr_SetString(PyExc_SystemError, "cython __annotate__ called without 'self' argument"); + } + Py_XINCREF(self); + return self; +} +static PyMethodDef __Pyx_CyFunction_annotate_method = { + "__annotate__", + (PyCFunction)(void (*)(void))__Pyx_CyFunction_annotate_impl, + METH_VARARGS, + "Placeholder __annotate__ function to allow 'functools.wraps' to work " + "on Cython functions." +}; +static PyObject * +__Pyx_CyFunction_get_annotate(PyObject *op_in, void *context) { + PyObject *annotate = NULL; + CYTHON_UNUSED_VAR(context); + if (unlikely(__Pyx_CyFunction_get_annotate_from_dict_if_exists(op_in, &annotate) < 0)) return NULL; + if (annotate) return annotate; + PyObject *annotations = __Pyx_CyFunction_get_annotations(op_in, NULL); + if (unlikely(!annotations)) return NULL; + PyObject *method = PyCFunction_New( + &__Pyx_CyFunction_annotate_method, + annotations); + Py_DECREF(annotations); + return method; +} +static int +__Pyx_CyFunction_set_annotate(PyObject *op_in, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + PyErr_SetString(PyExc_TypeError, "__annotate__ cannot be deleted"); + return -1; + } + if (unlikely(value != Py_None && !PyCallable_Check(value))) { + PyErr_SetString(PyExc_TypeError, "__annotate__ must be callable or None"); + return -1; + } + if (value != Py_None) { + __pyx_CyFunctionObject *op = (__pyx_CyFunctionObject*) op_in; + __Pyx_BEGIN_CRITICAL_SECTION(op_in); + Py_CLEAR(op->func_annotations); + __Pyx_END_CRITICAL_SECTION(); + } + return __Pyx_CyFunction_set_annotate_in_dict(op_in, value); +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine_value(__pyx_CyFunctionObject *op) { + int is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; + if (is_coroutine) { + PyObject *is_coroutine_value, *module, *fromlist, *marker = __pyx_mstate_global->__pyx_n_u_is_coroutine; + fromlist = PyList_New(1); + if (unlikely(!fromlist)) return NULL; + Py_INCREF(marker); +#if CYTHON_ASSUME_SAFE_MACROS + PyList_SET_ITEM(fromlist, 0, marker); +#else + if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { + Py_DECREF(fromlist); + return NULL; + } +#endif + module = PyImport_ImportModuleLevelObject(__pyx_mstate_global->__pyx_n_u_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + is_coroutine_value = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(is_coroutine_value)) { + return is_coroutine_value; + } +ignore: + PyErr_Clear(); + } + return __Pyx_PyBool_FromLong(is_coroutine); +} +static PyObject * +__Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + PyObject *result; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + result = __Pyx_CyFunction_get_is_coroutine_value(op); + if (unlikely(!result)) + return NULL; + __Pyx_BEGIN_CRITICAL_SECTION(op); + if (op->func_is_coroutine) { + Py_DECREF(result); + result = __Pyx_NewRef(op->func_is_coroutine); + } else { + op->func_is_coroutine = __Pyx_NewRef(result); + } + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static void __Pyx_CyFunction_raise_argument_count_error(__pyx_CyFunctionObject *func, const char* message, Py_ssize_t size) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; + PyErr_Format(PyExc_TypeError, + "%.200S() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, message, size); + Py_DECREF(py_name); +#else + const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", + name, message, size); +#endif +} +static void __Pyx_CyFunction_raise_type_error(__pyx_CyFunctionObject *func, const char* message) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; + PyErr_Format(PyExc_TypeError, + "%.200S() %s", + py_name, message); + Py_DECREF(py_name); +#else + const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s", + name, message); +#endif +} +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject * +__Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_GetAttrString(op->func, "__module__"); +} +static int +__Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_SetAttrString(op->func, "__module__", value); +} +#endif +static PyGetSetDef __pyx_CyFunction_getsets[] = { + {"func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {"__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {"__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + {"func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)PyObject_GenericSetDict, 0, 0}, + {"__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)PyObject_GenericSetDict, 0, 0}, +#else + {"func_dict", (getter)PyObject_GenericGetDict, (setter)PyObject_GenericSetDict, 0, 0}, + {"__dict__", (getter)PyObject_GenericGetDict, (setter)PyObject_GenericSetDict, 0, 0}, +#endif + {"func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {"__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {"func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {"__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {"func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {"__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {"func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {"__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {"__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {"__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {"__annotate__", (getter)__Pyx_CyFunction_get_annotate, (setter)__Pyx_CyFunction_set_annotate, 0, 0}, + {"_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, +#if CYTHON_COMPILING_IN_LIMITED_API + {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, +#endif + {0, 0, 0, 0, 0} +}; +static PyMemberDef __pyx_CyFunction_members[] = { +#if !CYTHON_COMPILING_IN_LIMITED_API + {"__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, +#endif +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + {"__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, +#endif +#if CYTHON_METH_FASTCALL +#if CYTHON_COMPILING_IN_LIMITED_API + {"__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, +#else + {"__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, +#else + {"__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, +#endif +#endif + {0, 0, 0, 0, 0} +}; +static PyObject * +__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) +{ + PyObject *result = NULL; + CYTHON_UNUSED_VAR(args); + __Pyx_BEGIN_CRITICAL_SECTION(m); + Py_INCREF(m->func_qualname); + result = m->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; +} +static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} +}; +#if CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) +#else +#define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) +#endif +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { +#if !CYTHON_COMPILING_IN_LIMITED_API + PyCFunctionObject *cf = (PyCFunctionObject*) op; +#endif + if (unlikely(op == NULL)) + return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); + if (unlikely(!op->func)) return NULL; +#endif + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; +#if !CYTHON_COMPILING_IN_LIMITED_API + cf->m_ml = ml; + cf->m_self = (PyObject *) op; +#endif + Py_XINCREF(closure); + op->func_closure = closure; +#if !CYTHON_COMPILING_IN_LIMITED_API + Py_XINCREF(module); + cf->m_module = module; +#endif +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + op->func_dict = NULL; +#endif + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + op->func_classobj = NULL; +#else + ((PyCMethodObject*)op)->mm_class = NULL; +#endif + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + op->func_is_coroutine = NULL; +#if CYTHON_METH_FASTCALL + switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { + case METH_NOARGS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; + break; + case METH_O: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; + break; + case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; + break; + case METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; + break; + case METH_VARARGS | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = NULL; + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + Py_DECREF(op); + return NULL; + } +#endif + return (PyObject *) op; +} +static int +__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) +{ + Py_CLEAR(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func); +#else + Py_CLEAR(((PyCFunctionObject*)m)->m_module); +#endif +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func_dict); +#elif PY_VERSION_HEX < 0x030d0000 + _PyObject_ClearManagedDict((PyObject*)m); +#else + PyObject_ClearManagedDict((PyObject*)m); +#endif + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); +#else + { + PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; + ((PyCMethodObject *) (m))->mm_class = NULL; + Py_XDECREF(cls); + } +#endif + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + Py_CLEAR(m->func_is_coroutine); + Py_CLEAR(m->defaults); + return 0; +} +static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + __Pyx_PyHeapTypeObject_GC_Del(m); +} +static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) +{ + PyObject_GC_UnTrack(m); + __Pyx__CyFunction_dealloc(m); +} +static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) +{ + { + int e = __Pyx_call_type_traverse((PyObject*)m, 1, visit, arg); + if (e) return e; + } + Py_VISIT(m->func_closure); +#if CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func); +#else + Py_VISIT(((PyCFunctionObject*)m)->m_module); +#endif +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func_dict); +#else + { + int e = +#if PY_VERSION_HEX < 0x030d0000 + _PyObject_VisitManagedDict +#else + PyObject_VisitManagedDict +#endif + ((PyObject*)m, visit, arg); + if (e != 0) return e; + } +#endif + __Pyx_VISIT_CONST(m->func_name); + __Pyx_VISIT_CONST(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + __Pyx_VISIT_CONST(m->func_code); + Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + Py_VISIT(m->func_annotations); + Py_VISIT(m->func_is_coroutine); + Py_VISIT(m->defaults); + return 0; +} +static PyObject* +__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) +{ + PyObject *repr; + __Pyx_BEGIN_CRITICAL_SECTION(op); + repr = PyUnicode_FromFormat("", + op->func_qualname, (void *)op); + __Pyx_END_CRITICAL_SECTION(); + return repr; +} +static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyCFunction meth; + int flags; + meth = PyCFunction_GetFunction(f); + if (unlikely(!meth)) return NULL; + flags = PyCFunction_GetFlags(f); + if (unlikely(flags < 0)) return NULL; +#else + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + int flags = f->m_ml->ml_flags; +#endif + Py_ssize_t size; + switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)(void(*)(void))meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_SIZE + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 0)) + return (*meth)(self, NULL); + __Pyx_CyFunction_raise_argument_count_error( + (__pyx_CyFunctionObject*)func, + "takes no arguments", size); + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { +#if CYTHON_ASSUME_SAFE_SIZE + size = PyTuple_GET_SIZE(arg); +#else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; +#endif + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; + #endif + result = (*meth)(self, arg0); + #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(arg0); + #endif + return result; + } + __Pyx_CyFunction_raise_argument_count_error( + (__pyx_CyFunctionObject*)func, + "takes exactly one argument", size); + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; + } + __Pyx_CyFunction_raise_type_error( + (__pyx_CyFunctionObject*)func, "takes no keyword arguments"); + return NULL; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *self, *result; +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)func)->m_self; +#endif + result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); + return result; +} +static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; +#if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE + return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); +#else + (void) &__Pyx_PyVectorcall_FastCallDict; + return PyVectorcall_Call(func, args, kw); +#endif + } +#endif + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; +#if CYTHON_ASSUME_SAFE_SIZE + argc = PyTuple_GET_SIZE(args); +#else + argc = PyTuple_Size(args); + if (unlikely(argc < 0)) return NULL; +#endif + new_args = PyTuple_GetSlice(args, 1, argc); + if (unlikely(!new_args)) + return NULL; + self = PyTuple_GetItem(args, 0); + if (unlikely(!self)) { + Py_DECREF(new_args); + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); + } + return result; +} +#if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL +static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) +{ + int ret = 0; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + if (unlikely(nargs < 1)) { + __Pyx_CyFunction_raise_type_error( + cyfunc, "needs an argument"); + return -1; + } + ret = 1; + } + if (unlikely(kwnames) && unlikely(__Pyx_PyTuple_GET_SIZE(kwnames))) { + __Pyx_CyFunction_raise_type_error( + cyfunc, "takes no keyword arguments"); + return -1; + } + return ret; +} +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + if (unlikely(nargs != 0)) { + __Pyx_CyFunction_raise_argument_count_error( + cyfunc, "takes no arguments", nargs); + return NULL; + } + return meth(self, NULL); +} +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + if (unlikely(nargs != 1)) { + __Pyx_CyFunction_raise_argument_count_error( + cyfunc, "takes exactly one argument", nargs); + return NULL; + } + return meth(self, args[0]); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))meth)(self, args, nargs, kwnames); +} +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) +{ + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + PyObject *self; +#if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; +#else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; +#endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: +#if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; +#else + self = ((PyCFunctionObject*)cyfunc)->m_self; +#endif + break; + default: + return NULL; + } + #if PY_VERSION_HEX < 0x030e00A6 + size_t nargs_value = (size_t) nargs; + #else + Py_ssize_t nargs_value = nargs; + #endif + return ((__Pyx_PyCMethod)(void(*)(void))meth)(self, cls, args, nargs_value, kwnames); +} +#endif +static PyType_Slot __pyx_CyFunctionType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, + {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, + {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, + {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, + {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, + {Py_tp_methods, (void *)__pyx_CyFunction_methods}, + {Py_tp_members, (void *)__pyx_CyFunction_members}, + {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, + {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, + {0, 0}, +}; +static PyType_Spec __pyx_CyFunctionType_spec = { + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, +#ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | +#endif +#if CYTHON_METH_FASTCALL +#if defined(Py_TPFLAGS_HAVE_VECTORCALL) + Py_TPFLAGS_HAVE_VECTORCALL | +#elif defined(_Py_TPFLAGS_HAVE_VECTORCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | +#endif +#endif // CYTHON_METH_FASTCALL +#if PY_VERSION_HEX >= 0x030C0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_TPFLAGS_MANAGED_DICT | +#endif + Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION | + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots +}; +static int __pyx_CyFunction_init(PyObject *module) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + mstate->__pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec( + mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_CyFunctionType_spec, NULL); + if (unlikely(mstate->__pyx_CyFunctionType == NULL)) { + return -1; + } + return 0; +} +static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, PyTypeObject *defaults_type) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_CallObject((PyObject*)defaults_type, NULL); // _PyObject_New(defaults_type); + if (unlikely(!m->defaults)) + return NULL; + return m->defaults; +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); +} +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); +} + +/* CythonFunction */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + PyObject *op = __Pyx_CyFunction_Init( + PyObject_GC_New(__pyx_CyFunctionObject, __pyx_mstate_global->__pyx_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); + } + return op; +} + +/* ListPack */ +static PyObject *__Pyx_PyList_Pack(Py_ssize_t n, ...) { + va_list va; + PyObject *l = PyList_New(n); + va_start(va, n); + if (unlikely(!l)) goto end; + for (Py_ssize_t i=0; i__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); + cython_runtime_dict = __Pyx_PyProbablyModule_GetDict(__pyx_mstate_global->__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, cython_runtime_dict, + __Pyx_PyDict_SetDefault(cython_runtime_dict, __pyx_mstate_global->__pyx_n_u_cline_in_traceback, Py_False)) + } + if (use_cline == NULL || use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + Py_XDECREF(use_cline); + Py_XDECREF(cython_runtime_dict); + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; +} +#endif + +/* CodeObjectCache (used by AddTraceback) */ +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 __Pyx_CachedCodeObjectType *__pyx__find_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line) { + __Pyx_CachedCodeObjectType* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!code_cache->entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); + if (unlikely(pos >= code_cache->count) || unlikely(code_cache->entries[pos].code_line != code_line)) { + return NULL; + } + code_object = code_cache->entries[pos].code_object; + Py_INCREF(code_object); + return code_object; +} +static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line) { +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS + (void)__pyx__find_code_object; + return NULL; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just miss. +#else + struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_nonatomic_int_type old_count = __pyx_atomic_incr_acq_rel(&code_cache->accessor_count); + if (old_count < 0) { + __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); + return NULL; + } +#endif + __Pyx_CachedCodeObjectType *result = __pyx__find_code_object(code_cache, code_line); +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); +#endif + return result; +#endif +} +static void __pyx__insert_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line, __Pyx_CachedCodeObjectType* code_object) +{ + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = code_cache->entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + code_cache->entries = entries; + code_cache->max_count = 64; + 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(code_cache->entries, code_cache->count, code_line); + if ((pos < code_cache->count) && unlikely(code_cache->entries[pos].code_line == code_line)) { + __Pyx_CachedCodeObjectType* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_INCREF(code_object); + Py_DECREF(tmp); + return; + } + if (code_cache->count == code_cache->max_count) { + int new_max = code_cache->max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + code_cache->entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + code_cache->entries = entries; + code_cache->max_count = new_max; + } + for (i=code_cache->count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + code_cache->count++; + Py_INCREF(code_object); +} +static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object) { +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS + (void)__pyx__insert_code_object; + return; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just fail. +#else + struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_nonatomic_int_type expected = 0; + if (!__pyx_atomic_int_cmp_exchange(&code_cache->accessor_count, &expected, INT_MIN)) { + return; + } +#endif + __pyx__insert_code_object(code_cache, code_line, code_object); +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_sub(&code_cache->accessor_count, INT_MIN); +#endif +#endif +} + +/* AddTraceback */ +#include "compile.h" +#include "frameobject.h" +#include "traceback.h" +#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API && !defined(PYPY_VERSION) + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, + PyObject *firstlineno, PyObject *name) { + PyObject *replace = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; + replace = PyObject_GetAttrString(code, "replace"); + if (likely(replace)) { + PyObject *result = PyObject_Call(replace, __pyx_mstate_global->__pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; + PyObject *replace = NULL, *getframe = NULL, *frame = NULL; + PyObject *exc_type, *exc_value, *exc_traceback; + int success = 0; + if (c_line) { + c_line = __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + } + PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); + code_object = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!code_object) { + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + if (c_line) { + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + } else { + py_funcname = PyUnicode_FromString(funcname); + } + if (unlikely(!py_funcname)) goto bad; + dict = PyDict_New(); + if (unlikely(!dict)) goto bad; + { + PyObject *old_code_object = code_object; + code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); + Py_DECREF(old_code_object); + } + if (unlikely(!code_object)) goto bad; + __pyx_insert_code_object(c_line ? -c_line : py_line, code_object); + } else { + dict = PyDict_New(); + } + getframe = PySys_GetObject("_getframe"); + if (unlikely(!getframe)) goto bad; + if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; + frame = PyEval_EvalCode(code_object, dict, dict); + if (unlikely(!frame) || frame == Py_None) goto bad; + success = 1; + bad: + PyErr_Restore(exc_type, exc_value, exc_traceback); + Py_XDECREF(code_object); + Py_XDECREF(py_py_line); + Py_XDECREF(py_funcname); + Py_XDECREF(dict); + Py_XDECREF(replace); + if (success) { + PyTraceBack_Here( + (struct _frame*)frame); + } + Py_XDECREF(frame); +} +#else +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 (c_line) { + 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; + } + py_code = PyCode_NewEmpty(filename, funcname, py_line); + Py_XDECREF(py_funcname); + return py_code; +bad: + Py_XDECREF(py_funcname); + return NULL; +} +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + 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_mstate_global->__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); +} +#endif + +/* MemviewRefcount */ +#include +#ifndef _Py_NO_RETURN +#define _Py_NO_RETURN +#endif +_Py_NO_RETURN +static void __pyx_fatalerror(const char *fmt, ...) { + va_list vargs; + char msg[200]; +#if PY_VERSION_HEX >= 0x030A0000 || defined(HAVE_STDARG_PROTOTYPES) + va_start(vargs, fmt); +#else + va_start(vargs); +#endif + vsnprintf(msg, 200, fmt, vargs); + va_end(vargs); + Py_FatalError(msg); +} +static CYTHON_INLINE int +__pyx_add_acquisition_count_locked(__pyx_atomic_int_type *acquisition_count, + PyThread_type_lock lock) +{ + int result; + PyThread_acquire_lock(lock, 1); + result = (*acquisition_count)++; + PyThread_release_lock(lock); + return result; +} +static CYTHON_INLINE int +__pyx_sub_acquisition_count_locked(__pyx_atomic_int_type *acquisition_count, + PyThread_type_lock lock) +{ + int result; + PyThread_acquire_lock(lock, 1); + result = (*acquisition_count)--; + PyThread_release_lock(lock); + return result; +} +static CYTHON_INLINE void +__Pyx_INC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno) +{ + __pyx_nonatomic_int_type old_acquisition_count; + struct __pyx_memoryview_obj *memview = memslice->memview; + if (unlikely(!memview || (PyObject *) memview == Py_None)) { + return; + } + old_acquisition_count = __pyx_add_acquisition_count(memview); + if (unlikely(old_acquisition_count <= 0)) { + if (likely(old_acquisition_count == 0)) { + if (have_gil) { + Py_INCREF((PyObject *) memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_INCREF((PyObject *) memview); + PyGILState_Release(_gilstate); + } + } else { + __pyx_fatalerror("Acquisition count is %d (line %d)", + old_acquisition_count+1, lineno); + } + } +} +static CYTHON_INLINE void __Pyx_XCLEAR_MEMVIEW(__Pyx_memviewslice *memslice, + int have_gil, int lineno) { + __pyx_nonatomic_int_type old_acquisition_count; + struct __pyx_memoryview_obj *memview = memslice->memview; + if (unlikely(!memview || (PyObject *) memview == Py_None)) { + memslice->memview = NULL; + return; + } + old_acquisition_count = __pyx_sub_acquisition_count(memview); + memslice->data = NULL; + if (likely(old_acquisition_count > 1)) { + memslice->memview = NULL; + } else if (likely(old_acquisition_count == 1)) { + if (have_gil) { + Py_CLEAR(memslice->memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_CLEAR(memslice->memview); + PyGILState_Release(_gilstate); + } + } else { + __pyx_fatalerror("Acquisition count is %d (line %d)", + old_acquisition_count-1, lineno); + } +} + +/* 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); +} + +/* 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((PyObject*)memview); + } + retval = 0; + goto no_fail; +fail: + memviewslice->memview = 0; + memviewslice->data = 0; + retval = -1; +no_fail: + __Pyx_RefNannyFinishContext(); + return retval; +} + +/* SliceMemoryviewSlice */ +static void __pyx_memoryview_slice_memviewslice_err_dim(PyObject *error, const char* msg, int dim) { + PyGILState_STATE gilstate = PyGILState_Ensure(); + PyErr_Format(error, msg, dim); + PyGILState_Release(gilstate); +} +static CYTHON_INLINE int __pyx_memoryview_slice_memviewslice( + __Pyx_memviewslice *dst, + Py_ssize_t shape, Py_ssize_t stride, Py_ssize_t suboffset, + int dim, int new_ndim, int *suboffset_dim, + Py_ssize_t start, Py_ssize_t stop, Py_ssize_t step, + int have_start, int have_stop, int have_step, + int is_slice) { + if (!is_slice) { + if (start < 0) { + start += shape; + } + if (unlikely(!(0 <= start && start < shape))) { + __pyx_memoryview_slice_memviewslice_err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim); + return -1; + } + } else { + int negative_step; + if (have_step) { + negative_step = step < 0; + if (unlikely(step == 0)) { + __pyx_memoryview_slice_memviewslice_err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim); + return -1; + } + } else { + negative_step = 0; + step = 1; + } + if (have_start) { + if (start < 0) { + start += shape; + if (start < 0) { + start = 0; + } + } else if (start >= shape) { + start = negative_step ? (shape - 1) : shape; + } + } else { + start = negative_step ? (shape - 1) : 0; + } + if (have_stop) { + if (stop < 0) { + stop += shape; + if (stop < 0) { + stop = 0; + } + } else if (stop > shape) { + stop = shape; + } + } else { + stop = negative_step ? -1 : shape; + } + Py_ssize_t new_shape = (stop - start) / step; + if ((stop - start) - step * new_shape) { + ++new_shape; + } + if (new_shape < 0) { + new_shape = 0; + } + dst->strides[new_ndim] = stride * step; + dst->shape[new_ndim] = new_shape; + dst->suboffsets[new_ndim] = suboffset; + } + if (suboffset_dim[0] < 0) { + dst->data += start * stride; + } else { + dst->suboffsets[suboffset_dim[0]] += start * stride; + } + if (suboffset >= 0) { + if (!is_slice) { + if (likely(new_ndim == 0)) { + dst->data = ((char **)(dst->data))[0] + suboffset; + } else { + __pyx_memoryview_slice_memviewslice_err_dim( + PyExc_IndexError, + "All dimensions preceding dimension %d must be indexed and not sliced", + dim); + return -1; + } + } else { + suboffset_dim[0] = new_ndim; + } + } + return 0; +} + +/* 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;\ + } + +/* MemviewDtypeToObject */ +static CYTHON_INLINE PyObject *__pyx_memview_get_nn___pyx_t_5numpy_int8_t(const char *itemp) { + return (PyObject *) __Pyx_PyLong_From_npy_int8(*(__pyx_t_5numpy_int8_t const *) itemp); +} +static CYTHON_INLINE int __pyx_memview_set_nn___pyx_t_5numpy_int8_t(char *itemp, PyObject *obj) { + __pyx_t_5numpy_int8_t value = __Pyx_PyLong_As_npy_int8(obj); + if (unlikely((value == ((npy_int8)-1)) && PyErr_Occurred())) + return 0; + *(__pyx_t_5numpy_int8_t *) itemp = value; + return 1; +} + +/* IsLittleEndian (used by BufferFormatCheck) */ +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 (used by MemviewSliceValidateAndInit) */ +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + const __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 "unparsable 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); + case 'q': case 'Q': return sizeof(PY_LONG_LONG); + 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; +typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; +static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, int is_complex) { + CYTHON_UNUSED_VAR(is_complex); + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); + case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); + 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; +typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, int is_complex) { + CYTHON_UNUSED_VAR(is_complex); + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); + case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); + 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 { + const __Pyx_StructField* field = ctx->head->field; + const __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 { + const __Pyx_StructField* field = ctx->head->field; + const __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 int +__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 -1; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return -1; + 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 -1; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + return -1; + } + if (*ts != ',' && *ts != ')') { + PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + return -1; + } + if (*ts == ',') ts++; + i++; + } + if (i != ndim) { + PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + return -1; + } + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return -1; + } + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return 0; +} +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) < 0) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; + } + } + } +} + +/* TypeInfoCompare (used by MemviewSliceValidateAndInit) */ + static int + __pyx_typeinfo_cmp(const __Pyx_TypeInfo *a, const __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++) { + const __Pyx_StructField *field_a = a->fields + i; + const __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 (used by ObjectToMemviewSlice) */ + 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, int ndim, int spec) + { + CYTHON_UNUSED_VAR(ndim); + if (spec & __Pyx_MEMVIEW_DIRECT) { + if (unlikely(buf->suboffsets && buf->suboffsets[dim] >= 0)) { + PyErr_Format(PyExc_ValueError, + "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, + const __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((PyObject*)new_memview); + retval = -1; + no_fail: + __Pyx_RefNannyFinishContext(); + return retval; + } + +/* ObjectToMemviewSlice */ + static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dsds_nn___pyx_t_5numpy_int8_t(PyObject *obj, int writable_flag) { + __Pyx_memviewslice result = __Pyx_MEMSLICE_INIT; + __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___pyx_t_5numpy_int8_t, stack, + &result, obj); + if (unlikely(retcode == -1)) + goto __pyx_fail; + return result; + __pyx_fail: + result.memview = NULL; + result.data = NULL; + return result; + } + +/* CheckUnpickleChecksum */ + static void __Pyx_RaiseUnpickleChecksumError(long checksum, long checksum1, long checksum2, long checksum3, const char *members) { + PyObject *pickle_module = PyImport_ImportModule("pickle"); + if (unlikely(!pickle_module)) return; + PyObject *pickle_error = PyObject_GetAttrString(pickle_module, "PickleError"); + Py_DECREF(pickle_module); + if (unlikely(!pickle_error)) return; + if (checksum2 == checksum1) { + PyErr_Format(pickle_error, "Incompatible checksums (0x%x vs (0x%x) = (%s))", + checksum, checksum1, members); + } else if (checksum3 == checksum2) { + PyErr_Format(pickle_error, "Incompatible checksums (0x%x vs (0x%x, 0x%x) = (%s))", + checksum, checksum1, checksum2, members); + } else { + PyErr_Format(pickle_error, "Incompatible checksums (0x%x vs (0x%x, 0x%x, 0x%x) = (%s))", + checksum, checksum1, checksum2, checksum3, members); + } + Py_DECREF(pickle_error); + } + static int __Pyx_CheckUnpickleChecksum(long checksum, long checksum1, long checksum2, long checksum3, const char *members) { + int found = 0; + found |= checksum1 == checksum; + found |= checksum2 == checksum; + found |= checksum3 == checksum; + if (likely(found)) + return 0; + __Pyx_RaiseUnpickleChecksumError(checksum, checksum1, checksum2, checksum3, members); + return -1; + } + +/* Declarations */ + #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return ::std::complex< float >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return x + y*(__pyx_t_float_complex)_Complex_I; + } + #endif + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + __pyx_t_float_complex z; + z.real = x; + z.imag = y; + return z; + } + #endif + +/* Arithmetic */ + #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #else + static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + if (b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabsf(b.real) >= fabsf(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + float r = b.imag / b.real; + float s = (float)(1.0) / (b.real + b.imag * r); + return __pyx_t_float_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + float r = b.real / b.imag; + float s = (float)(1.0) / (b.imag + b.real * r); + return __pyx_t_float_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + if (b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + float denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_float_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtf(z.real*z.real + z.imag*z.imag); + #else + return hypotf(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + float denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_float(a, a); + case 3: + z = __Pyx_c_prod_float(a, a); + return __Pyx_c_prod_float(z, a); + case 4: + z = __Pyx_c_prod_float(a, a); + return __Pyx_c_prod_float(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if ((b.imag == 0) && (a.real >= 0)) { + z.real = powf(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2f(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_float(a); + theta = atan2f(a.imag, a.real); + } + lnr = logf(r); + z_r = expf(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosf(z_theta); + z.imag = z_r * sinf(z_theta); + return z; + } + #endif + #endif + +/* Declarations */ + #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return ::std::complex< double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return x + y*(__pyx_t_double_complex)_Complex_I; + } + #endif + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + __pyx_t_double_complex z; + z.real = x; + z.imag = y; + return z; + } + #endif + +/* Arithmetic */ + #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #else + static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + if (b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabs(b.real) >= fabs(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + double r = b.imag / b.real; + double s = (double)(1.0) / (b.real + b.imag * r); + return __pyx_t_double_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + double r = b.real / b.imag; + double s = (double)(1.0) / (b.imag + b.real * r); + return __pyx_t_double_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + if (b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + double denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_double_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrt(z.real*z.real + z.imag*z.imag); + #else + return hypot(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_double(a, a); + case 3: + z = __Pyx_c_prod_double(a, a); + return __Pyx_c_prod_double(z, a); + case 4: + z = __Pyx_c_prod_double(a, a); + return __Pyx_c_prod_double(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if ((b.imag == 0) && (a.real >= 0)) { + z.real = pow(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_double(a); + theta = atan2(a.imag, a.real); + } + lnr = log(r); + z_r = exp(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cos(z_theta); + z.imag = z_r * sin(z_theta); + return z; + } + #endif + #endif + +/* Declarations */ + #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_from_parts(long double x, long double y) { + return ::std::complex< long double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_from_parts(long double x, long double y) { + return x + y*(__pyx_t_long_double_complex)_Complex_I; + } + #endif + #else + static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_from_parts(long double x, long double y) { + __pyx_t_long_double_complex z; + z.real = x; + z.imag = y; + return z; + } + #endif + +/* Arithmetic */ + #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #else + static CYTHON_INLINE int __Pyx_c_eq_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_sum_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + __pyx_t_long_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_diff_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + __pyx_t_long_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_prod_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + __pyx_t_long_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_quot_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + if (b.imag == 0) { + return __pyx_t_long_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabsl(b.real) >= fabsl(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_long_double_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + long double r = b.imag / b.real; + long double s = (long double)(1.0) / (b.real + b.imag * r); + return __pyx_t_long_double_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + long double r = b.real / b.imag; + long double s = (long double)(1.0) / (b.imag + b.real * r); + return __pyx_t_long_double_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_quot_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + if (b.imag == 0) { + return __pyx_t_long_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + long double denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_long_double_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_neg_long__double(__pyx_t_long_double_complex a) { + __pyx_t_long_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_long__double(__pyx_t_long_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_conj_long__double(__pyx_t_long_double_complex a) { + __pyx_t_long_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE long double __Pyx_c_abs_long__double(__pyx_t_long_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtl(z.real*z.real + z.imag*z.imag); + #else + return hypotl(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_pow_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + __pyx_t_long_double_complex z; + long double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + long double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_long__double(a, a); + case 3: + z = __Pyx_c_prod_long__double(a, a); + return __Pyx_c_prod_long__double(z, a); + case 4: + z = __Pyx_c_prod_long__double(a, a); + return __Pyx_c_prod_long__double(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if ((b.imag == 0) && (a.real >= 0)) { + z.real = powl(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2l(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_long__double(a); + theta = atan2l(a.imag, a.real); + } + lnr = logl(r); + z_r = expl(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosl(z_theta); + z.imag = z_r * sinl(z_theta); + return z; + } + #endif + #endif + +/* MemviewSliceCopy */ + 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 = __Pyx_MEMSLICE_INIT; + struct __pyx_memoryview_obj *from_memview = from_mvs->memview; + Py_buffer *buf = &from_memview->view; + PyObject *shape_tuple = 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++) { + PyObject *temp_int = PyLong_FromSsize_t(from_mvs->shape[i]); + if(unlikely(!temp_int)) { + goto fail; + } else { + #if CYTHON_ASSUME_SAFE_MACROS + PyTuple_SET_ITEM(shape_tuple, i, temp_int); + #else + if (PyTuple_SetItem(shape_tuple, i, temp_int) < 0) { + goto fail; + } + #endif + } + } + array_obj = __pyx_array_new(shape_tuple, sizeof_dtype, buf->format, 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((PyObject *) new_mvs.memview); + new_mvs.memview = NULL; + new_mvs.data = NULL; + no_fail: + __Pyx_XDECREF(shape_tuple); + __Pyx_XDECREF((PyObject *) array_obj); + __Pyx_RefNannyFinishContext(); + return new_mvs; + } + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyLong_From_npy_int8(npy_int8 value) { + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wconversion" + #endif + const npy_int8 neg_one = (npy_int8) -1, const_zero = (npy_int8) 0; + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic pop + #endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(npy_int8) < sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(npy_int8) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + #if !CYTHON_COMPILING_IN_PYPY + } else if (sizeof(npy_int8) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + #endif + } + } else { + if (sizeof(npy_int8) <= sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(npy_int8) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + unsigned char *bytes = (unsigned char *)&value; + #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 + if (is_unsigned) { + return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); + } else { + return PyLong_FromNativeBytes(bytes, sizeof(value), -1); + } + #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + int one = 1; int little = (int)*(unsigned char *)&one; + return _PyLong_FromByteArray(bytes, sizeof(npy_int8), + little, !is_unsigned); + #else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(npy_int8)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; + } + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; + #endif + } + } + +/* CIntFromPy */ + static CYTHON_INLINE npy_int8 __Pyx_PyLong_As_npy_int8(PyObject *x) { + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wconversion" + #endif + const npy_int8 neg_one = (npy_int8) -1, const_zero = (npy_int8) 0; + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic pop + #endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!PyLong_Check(x))) { + npy_int8 val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (npy_int8) -1; + val = __Pyx_PyLong_As_npy_int8(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { + #if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(npy_int8, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(npy_int8) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(npy_int8, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(npy_int8) >= 2 * PyLong_SHIFT)) { + return (npy_int8) (((((npy_int8)digits[1]) << PyLong_SHIFT) | (npy_int8)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(npy_int8) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(npy_int8, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(npy_int8) >= 3 * PyLong_SHIFT)) { + return (npy_int8) (((((((npy_int8)digits[2]) << PyLong_SHIFT) | (npy_int8)digits[1]) << PyLong_SHIFT) | (npy_int8)digits[0])); + } + } + break; + case 4: + if ((8 * sizeof(npy_int8) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(npy_int8, 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(npy_int8) >= 4 * PyLong_SHIFT)) { + return (npy_int8) (((((((((npy_int8)digits[3]) << PyLong_SHIFT) | (npy_int8)digits[2]) << PyLong_SHIFT) | (npy_int8)digits[1]) << PyLong_SHIFT) | (npy_int8)digits[0])); + } + } + break; + } + } + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + 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 (npy_int8) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } + #endif + if ((sizeof(npy_int8) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(npy_int8, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(npy_int8) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(npy_int8, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { + #if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(npy_int8, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(npy_int8) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(npy_int8, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(npy_int8) - 1 > 2 * PyLong_SHIFT)) { + return (npy_int8) (((npy_int8)-1)*(((((npy_int8)digits[1]) << PyLong_SHIFT) | (npy_int8)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(npy_int8) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(npy_int8, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(npy_int8) - 1 > 2 * PyLong_SHIFT)) { + return (npy_int8) ((((((npy_int8)digits[1]) << PyLong_SHIFT) | (npy_int8)digits[0]))); + } + } + break; + case -3: + if ((8 * sizeof(npy_int8) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(npy_int8, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(npy_int8) - 1 > 3 * PyLong_SHIFT)) { + return (npy_int8) (((npy_int8)-1)*(((((((npy_int8)digits[2]) << PyLong_SHIFT) | (npy_int8)digits[1]) << PyLong_SHIFT) | (npy_int8)digits[0]))); + } + } + break; + case 3: + if ((8 * sizeof(npy_int8) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(npy_int8, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(npy_int8) - 1 > 3 * PyLong_SHIFT)) { + return (npy_int8) ((((((((npy_int8)digits[2]) << PyLong_SHIFT) | (npy_int8)digits[1]) << PyLong_SHIFT) | (npy_int8)digits[0]))); + } + } + break; + case -4: + if ((8 * sizeof(npy_int8) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(npy_int8, 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(npy_int8) - 1 > 4 * PyLong_SHIFT)) { + return (npy_int8) (((npy_int8)-1)*(((((((((npy_int8)digits[3]) << PyLong_SHIFT) | (npy_int8)digits[2]) << PyLong_SHIFT) | (npy_int8)digits[1]) << PyLong_SHIFT) | (npy_int8)digits[0]))); + } + } + break; + case 4: + if ((8 * sizeof(npy_int8) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(npy_int8, 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(npy_int8) - 1 > 4 * PyLong_SHIFT)) { + return (npy_int8) ((((((((((npy_int8)digits[3]) << PyLong_SHIFT) | (npy_int8)digits[2]) << PyLong_SHIFT) | (npy_int8)digits[1]) << PyLong_SHIFT) | (npy_int8)digits[0]))); + } + } + break; + } + } + #endif + if ((sizeof(npy_int8) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(npy_int8, long, PyLong_AsLong(x)) + } else if ((sizeof(npy_int8) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(npy_int8, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + npy_int8 val; + int ret = -1; + #if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } + #elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); + #else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (npy_int8) -1; + assert(PyLong_CheckExact(v)); + } + { + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { + Py_DECREF(v); + return (npy_int8) -1; + } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (npy_int8) -1; + } else { + stepval = v; + } + v = NULL; + val = (npy_int8) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(npy_int8) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((npy_int8) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(npy_int8) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((npy_int8) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((npy_int8) 1) << (sizeof(npy_int8) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); + #endif + if (unlikely(ret)) + return (npy_int8) -1; + return val; + } + raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to npy_int8"); + return (npy_int8) -1; + raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to npy_int8"); + return (npy_int8) -1; + } + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyLong_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 PyLong_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + #if !CYTHON_COMPILING_IN_PYPY + } 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 PyLong_FromLong((long) value); + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + unsigned char *bytes = (unsigned char *)&value; + #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 + if (is_unsigned) { + return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); + } else { + return PyLong_FromNativeBytes(bytes, sizeof(value), -1); + } + #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + int one = 1; int little = (int)*(unsigned char *)&one; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + #else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; + } + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; + #endif + } + } + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyLong_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 (unlikely(!PyLong_Check(x))) { + int val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (int) -1; + val = __Pyx_PyLong_As_int(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { + #if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 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 && PY_VERSION_HEX < 0x030C00A7 + 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)) + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { + #if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -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)) + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + int val; + int ret = -1; + #if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } + #elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); + #else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (int) -1; + assert(PyLong_CheckExact(v)); + } + { + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { + Py_DECREF(v); + return (int) -1; + } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = v; + } + v = NULL; + val = (int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((int) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((int) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); + #endif + if (unlikely(ret)) + return (int) -1; + return val; + } + raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; + raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; + } + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyLong_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 (unlikely(!PyLong_Check(x))) { + long val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (long) -1; + val = __Pyx_PyLong_As_long(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { + #if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 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 && PY_VERSION_HEX < 0x030C00A7 + 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)) + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { + #if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -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)) + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + long val; + int ret = -1; + #if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } + #elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); + #else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (long) -1; + assert(PyLong_CheckExact(v)); + } + { + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { + Py_DECREF(v); + return (long) -1; + } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = v; + } + v = NULL; + val = (long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((long) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((long) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); + #endif + if (unlikely(ret)) + return (long) -1; + 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_PyLong_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 PyLong_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + #if !CYTHON_COMPILING_IN_PYPY + } 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 PyLong_FromLong((long) value); + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + unsigned char *bytes = (unsigned char *)&value; + #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 + if (is_unsigned) { + return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); + } else { + return PyLong_FromNativeBytes(bytes, sizeof(value), -1); + } + #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + int one = 1; int little = (int)*(unsigned char *)&one; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + #else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; + } + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; + #endif + } + } + +/* PyObjectCall2Args */ + static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { + PyObject *args[3] = {NULL, arg1, arg2}; + return __Pyx_PyObject_FastCall(function, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); + } + +/* PyObjectCallMethod1 */ + #if !(CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))) + static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) { + PyObject *result = __Pyx_PyObject_CallOneArg(method, arg); + Py_DECREF(method); + return result; + } + #endif + static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { + #if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000)) + PyObject *args[2] = {obj, arg}; + (void) __Pyx_PyObject_CallOneArg; + (void) __Pyx_PyObject_Call2Args; + return PyObject_VectorcallMethod(method_name, args, 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); + #else + PyObject *method = NULL, *result; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_Call2Args(method, obj, arg); + Py_DECREF(method); + return result; + } + if (unlikely(!method)) return NULL; + return __Pyx__PyObject_CallMethod1(method, arg); + #endif + } + +/* UpdateUnpickledDict */ + static int __Pyx__UpdateUnpickledDict(PyObject *obj, PyObject *state, Py_ssize_t index) { + PyObject *state_dict = __Pyx_PySequence_ITEM(state, index); + if (unlikely(!state_dict)) { + return -1; + } + int non_empty = PyObject_IsTrue(state_dict); + if (non_empty == 0) { + Py_DECREF(state_dict); + return 0; + } else if (unlikely(non_empty == -1)) { + return -1; + } + PyObject *dict; + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + dict = PyObject_GetAttrString(obj, "__dict__"); + #else + dict = PyObject_GenericGetDict(obj, NULL); + #endif + if (unlikely(!dict)) { + Py_DECREF(state_dict); + return -1; + } + int result; + if (likely(PyDict_CheckExact(dict))) { + result = PyDict_Update(dict, state_dict); + } else { + PyObject *obj_result = __Pyx_PyObject_CallMethod1(dict, __pyx_mstate_global->__pyx_n_u_update, state_dict); + if (likely(obj_result)) { + Py_DECREF(obj_result); + result = 0; + } else { + result = -1; + } + } + Py_DECREF(state_dict); + Py_DECREF(dict); + return result; + } + static int __Pyx_UpdateUnpickledDict(PyObject *obj, PyObject *state, Py_ssize_t index) { + Py_ssize_t state_size = __Pyx_PyTuple_GET_SIZE(state); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(state_size == -1)) return -1; + #endif + if (state_size <= index) { + return 0; + } + return __Pyx__UpdateUnpickledDict(obj, state, index); + } + +/* CIntFromPy */ + static CYTHON_INLINE char __Pyx_PyLong_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 (unlikely(!PyLong_Check(x))) { + char val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (char) -1; + val = __Pyx_PyLong_As_char(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { + #if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(char, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(char) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(char) >= 2 * PyLong_SHIFT)) { + return (char) (((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(char) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(char) >= 3 * PyLong_SHIFT)) { + return (char) (((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + case 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 && PY_VERSION_HEX < 0x030C00A7 + 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)) + } else if ((sizeof(char) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { + #if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(char, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(char) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(char) - 1 > 2 * PyLong_SHIFT)) { + return (char) (((char)-1)*(((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(char) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(char) - 1 > 2 * PyLong_SHIFT)) { + return (char) ((((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case -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)) + } else if ((sizeof(char) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(char, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + char val; + int ret = -1; + #if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } + #elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); + #else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (char) -1; + assert(PyLong_CheckExact(v)); + } + { + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { + Py_DECREF(v); + return (char) -1; + } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (char) -1; + } else { + stepval = v; + } + v = NULL; + val = (char) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(char) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((char) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(char) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((char) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((char) 1) << (sizeof(char) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); + #endif + if (unlikely(ret)) + return (char) -1; + 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; + } + +/* FormatTypeName */ + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 + static __Pyx_TypeName + __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp) + { + PyObject *module = NULL, *name = NULL, *result = NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_mstate_global->__pyx_n_u_qualname); + #else + name = PyType_GetQualName(tp); + #endif + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) goto bad; + module = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_mstate_global->__pyx_n_u_module); + if (unlikely(module == NULL) || unlikely(!PyUnicode_Check(module))) goto bad; + if (PyUnicode_CompareWithASCIIString(module, "builtins") == 0) { + result = name; + name = NULL; + goto done; + } + result = PyUnicode_FromFormat("%U.%U", module, name); + if (unlikely(result == NULL)) goto bad; + done: + Py_XDECREF(name); + Py_XDECREF(module); + return result; + bad: + PyErr_Clear(); + if (name) { + result = name; + name = NULL; + } else { + result = __Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u__8); + } + goto done; + } + #endif + +/* GetRuntimeVersion */ + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + void __Pyx_init_runtime_version(void) { + if (__Pyx_cached_runtime_version == 0) { + const char* rt_version = Py_GetVersion(); + unsigned long version = 0; + unsigned long factor = 0x01000000UL; + unsigned int digit = 0; + int i = 0; + while (factor) { + while ('0' <= rt_version[i] && rt_version[i] <= '9') { + digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + ++i; + } + version += factor * digit; + if (rt_version[i] != '.') + break; + digit = 0; + factor >>= 8; + ++i; + } + __Pyx_cached_runtime_version = version; + } + } + #endif + static unsigned long __Pyx_get_runtime_version(void) { + #if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + return Py_Version & ~0xFFUL; + #else + return __Pyx_cached_runtime_version; + #endif + } + +/* IterNextPlain (used by CoroutineBase) */ + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + static PyObject *__Pyx_GetBuiltinNext_LimitedAPI(void) { + if (unlikely(!__pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache)) + __pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache = __Pyx_GetBuiltinName(__pyx_mstate_global->__pyx_n_u_next); + return __pyx_mstate_global->__Pyx_GetBuiltinNext_LimitedAPI_cache; + } + #endif + static CYTHON_INLINE PyObject *__Pyx_PyIter_Next_Plain(PyObject *iterator) { + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + PyObject *result; + PyObject *next = __Pyx_GetBuiltinNext_LimitedAPI(); + if (unlikely(!next)) return NULL; + result = PyObject_CallFunctionObjArgs(next, iterator, NULL); + return result; + #else + (void)__Pyx_GetBuiltinName; // only for early limited API + iternextfunc iternext = __Pyx_PyObject_GetIterNextFunc(iterator); + assert(iternext); + return iternext(iterator); + #endif + } + +/* ReturnWithStopIteration (used by CoroutineBase) */ + static void __Pyx__ReturnWithStopIteration(PyObject* value, int async); + static CYTHON_INLINE void __Pyx_ReturnWithStopIteration(PyObject* value, int async, int iternext) { + if (value == Py_None) { + if (async || !iternext) + PyErr_SetNone(async ? PyExc_StopAsyncIteration : PyExc_StopIteration); + return; + } + __Pyx__ReturnWithStopIteration(value, async); + } + static void __Pyx__ReturnWithStopIteration(PyObject* value, int async) { + #if CYTHON_COMPILING_IN_CPYTHON + __Pyx_PyThreadState_declare + #endif + PyObject *exc; + PyObject *exc_type = async ? PyExc_StopAsyncIteration : PyExc_StopIteration; + #if CYTHON_COMPILING_IN_CPYTHON + if ((PY_VERSION_HEX >= (0x030C00A6)) || unlikely(PyTuple_Check(value) || PyExceptionInstance_Check(value))) { + if (PY_VERSION_HEX >= (0x030e00A1)) { + exc = __Pyx_PyObject_CallOneArg(exc_type, value); + } else { + PyObject *args_tuple = PyTuple_New(1); + if (unlikely(!args_tuple)) return; + Py_INCREF(value); + PyTuple_SET_ITEM(args_tuple, 0, value); + exc = PyObject_Call(exc_type, args_tuple, NULL); + Py_DECREF(args_tuple); + } + if (unlikely(!exc)) return; + } else { + Py_INCREF(value); + exc = value; + } + #if CYTHON_FAST_THREAD_STATE + __Pyx_PyThreadState_assign + #if CYTHON_USE_EXC_INFO_STACK + if (!__pyx_tstate->exc_info->exc_value) + #else + if (!__pyx_tstate->exc_type) + #endif + { + Py_INCREF(exc_type); + __Pyx_ErrRestore(exc_type, exc, NULL); + return; + } + #endif + #else + exc = __Pyx_PyObject_CallOneArg(exc_type, value); + if (unlikely(!exc)) return; + #endif + PyErr_SetObject(exc_type, exc); + Py_DECREF(exc); + } + +/* CoroutineBase (used by Generator) */ + #if !CYTHON_COMPILING_IN_LIMITED_API + #include + #if PY_VERSION_HEX >= 0x030b00a6 && !defined(PYPY_VERSION) + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" + #endif + #endif // CYTHON_COMPILING_IN_LIMITED_API + static CYTHON_INLINE void + __Pyx_Coroutine_Undelegate(__pyx_CoroutineObject *gen) { + #if CYTHON_USE_AM_SEND + gen->yieldfrom_am_send = NULL; + #endif + Py_CLEAR(gen->yieldfrom); + } + static int __Pyx_PyGen__FetchStopIterationValue(PyThreadState *__pyx_tstate, PyObject **pvalue) { + PyObject *et, *ev, *tb; + PyObject *value = NULL; + CYTHON_UNUSED_VAR(__pyx_tstate); + __Pyx_ErrFetch(&et, &ev, &tb); + if (!et) { + Py_XDECREF(tb); + Py_XDECREF(ev); + Py_INCREF(Py_None); + *pvalue = Py_None; + return 0; + } + if (likely(et == PyExc_StopIteration)) { + if (!ev) { + Py_INCREF(Py_None); + value = Py_None; + } + else if (likely(__Pyx_IS_TYPE(ev, (PyTypeObject*)PyExc_StopIteration))) { + #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL + value = PyObject_GetAttr(ev, __pyx_mstate_global->__pyx_n_u_value); + if (unlikely(!value)) goto limited_api_failure; + #else + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); + #endif + Py_DECREF(ev); + } + else if (unlikely(PyTuple_Check(ev))) { + Py_ssize_t tuple_size = __Pyx_PyTuple_GET_SIZE(ev); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(tuple_size < 0)) { + Py_XDECREF(tb); + Py_DECREF(ev); + Py_DECREF(et); + return -1; + } + #endif + if (tuple_size >= 1) { + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + value = PyTuple_GET_ITEM(ev, 0); + Py_INCREF(value); + #elif CYTHON_ASSUME_SAFE_MACROS + value = PySequence_ITEM(ev, 0); + #else + value = PySequence_GetItem(ev, 0); + if (!value) goto limited_api_failure; + #endif + } else { + Py_INCREF(Py_None); + value = Py_None; + } + Py_DECREF(ev); + } + else if (!__Pyx_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration)) { + value = ev; + } + if (likely(value)) { + Py_XDECREF(tb); + Py_DECREF(et); + *pvalue = value; + return 0; + } + } else if (!__Pyx_PyErr_GivenExceptionMatches(et, PyExc_StopIteration)) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + PyErr_NormalizeException(&et, &ev, &tb); + if (unlikely(!PyObject_TypeCheck(ev, (PyTypeObject*)PyExc_StopIteration))) { + __Pyx_ErrRestore(et, ev, tb); + return -1; + } + Py_XDECREF(tb); + Py_DECREF(et); + #if CYTHON_COMPILING_IN_LIMITED_API + value = PyObject_GetAttr(ev, __pyx_mstate_global->__pyx_n_u_value); + #else + value = ((PyStopIterationObject *)ev)->value; + Py_INCREF(value); + #endif + Py_DECREF(ev); + #if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!value)) return -1; + #endif + *pvalue = value; + return 0; + #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL || !CYTHON_ASSUME_SAFE_MACROS + limited_api_failure: + Py_XDECREF(et); + Py_XDECREF(tb); + Py_XDECREF(ev); + return -1; + #endif + } + static CYTHON_INLINE + __Pyx_PySendResult __Pyx_Coroutine_status_from_result(PyObject **retval) { + if (*retval) { + return PYGEN_NEXT; + } else if (likely(__Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, retval) == 0)) { + return PYGEN_RETURN; + } else { + return PYGEN_ERROR; + } + } + static CYTHON_INLINE + void __Pyx_Coroutine_ExceptionClear(__Pyx_ExcInfoStruct *exc_state) { + #if PY_VERSION_HEX >= 0x030B00a4 + Py_CLEAR(exc_state->exc_value); + #else + PyObject *t, *v, *tb; + t = exc_state->exc_type; + v = exc_state->exc_value; + tb = exc_state->exc_traceback; + exc_state->exc_type = NULL; + exc_state->exc_value = NULL; + exc_state->exc_traceback = NULL; + Py_XDECREF(t); + Py_XDECREF(v); + Py_XDECREF(tb); + #endif + } + #define __Pyx_Coroutine_AlreadyRunningError(gen) (__Pyx__Coroutine_AlreadyRunningError(gen), (PyObject*)NULL) + static void __Pyx__Coroutine_AlreadyRunningError(__pyx_CoroutineObject *gen) { + const char *msg; + CYTHON_MAYBE_UNUSED_VAR(gen); + if ((0)) { + #ifdef __Pyx_Coroutine_USED + } else if (__Pyx_Coroutine_Check((PyObject*)gen)) { + msg = "coroutine already executing"; + #endif + #ifdef __Pyx_AsyncGen_USED + } else if (__Pyx_AsyncGen_CheckExact((PyObject*)gen)) { + msg = "async generator already executing"; + #endif + } else { + msg = "generator already executing"; + } + PyErr_SetString(PyExc_ValueError, msg); + } + static void __Pyx_Coroutine_AlreadyTerminatedError(PyObject *gen, PyObject *value, int closing) { + CYTHON_MAYBE_UNUSED_VAR(gen); + CYTHON_MAYBE_UNUSED_VAR(closing); + #ifdef __Pyx_Coroutine_USED + if (!closing && __Pyx_Coroutine_Check(gen)) { + PyErr_SetString(PyExc_RuntimeError, "cannot reuse already awaited coroutine"); + } else + #endif + if (value) { + #ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(gen)) + PyErr_SetNone(PyExc_StopAsyncIteration); + else + #endif + PyErr_SetNone(PyExc_StopIteration); + } + } + static + __Pyx_PySendResult __Pyx_Coroutine_SendEx(__pyx_CoroutineObject *self, PyObject *value, PyObject **result, int closing) { + __Pyx_PyThreadState_declare + PyThreadState *tstate; + __Pyx_ExcInfoStruct *exc_state; + PyObject *retval; + assert(__Pyx_Coroutine_get_is_running(self)); // Callers should ensure is_running + if (unlikely(self->resume_label == -1)) { + __Pyx_Coroutine_AlreadyTerminatedError((PyObject*)self, value, closing); + return PYGEN_ERROR; + } + #if CYTHON_FAST_THREAD_STATE + __Pyx_PyThreadState_assign + tstate = __pyx_tstate; + #else + tstate = __Pyx_PyThreadState_Current; + #endif + exc_state = &self->gi_exc_state; + if (exc_state->exc_value) { + #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + #else + PyObject *exc_tb; + #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_CPYTHON + exc_tb = PyException_GetTraceback(exc_state->exc_value); + #elif PY_VERSION_HEX >= 0x030B00a4 + exc_tb = ((PyBaseExceptionObject*) exc_state->exc_value)->traceback; + #else + exc_tb = exc_state->exc_traceback; + #endif + if (exc_tb) { + PyTracebackObject *tb = (PyTracebackObject *) exc_tb; + PyFrameObject *f = tb->tb_frame; + assert(f->f_back == NULL); + #if PY_VERSION_HEX >= 0x030B00A1 + f->f_back = PyThreadState_GetFrame(tstate); + #else + Py_XINCREF(tstate->frame); + f->f_back = tstate->frame; + #endif + #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_CPYTHON + Py_DECREF(exc_tb); + #endif + } + #endif + } + #if CYTHON_USE_EXC_INFO_STACK + exc_state->previous_item = tstate->exc_info; + tstate->exc_info = exc_state; + #else + if (exc_state->exc_type) { + __Pyx_ExceptionSwap(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback); + } else { + __Pyx_Coroutine_ExceptionClear(exc_state); + __Pyx_ExceptionSave(&exc_state->exc_type, &exc_state->exc_value, &exc_state->exc_traceback); + } + #endif + retval = self->body(self, tstate, value); + #if CYTHON_USE_EXC_INFO_STACK + exc_state = &self->gi_exc_state; + tstate->exc_info = exc_state->previous_item; + exc_state->previous_item = NULL; + __Pyx_Coroutine_ResetFrameBackpointer(exc_state); + #endif + *result = retval; + if (self->resume_label == -1) { + return likely(retval) ? PYGEN_RETURN : PYGEN_ERROR; + } + return PYGEN_NEXT; + } + static CYTHON_INLINE void __Pyx_Coroutine_ResetFrameBackpointer(__Pyx_ExcInfoStruct *exc_state) { + #if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED_VAR(exc_state); + #else + PyObject *exc_tb; + #if PY_VERSION_HEX >= 0x030B00a4 + if (!exc_state->exc_value) return; + exc_tb = PyException_GetTraceback(exc_state->exc_value); + #else + exc_tb = exc_state->exc_traceback; + #endif + if (likely(exc_tb)) { + PyTracebackObject *tb = (PyTracebackObject *) exc_tb; + PyFrameObject *f = tb->tb_frame; + Py_CLEAR(f->f_back); + #if PY_VERSION_HEX >= 0x030B00a4 + Py_DECREF(exc_tb); + #endif + } + #endif + } + #define __Pyx_Coroutine_MethodReturnFromResult(gen, result, retval, iternext)\ + ((result) == PYGEN_NEXT ? (retval) : __Pyx__Coroutine_MethodReturnFromResult(gen, result, retval, iternext)) + static PyObject * + __Pyx__Coroutine_MethodReturnFromResult(PyObject* gen, __Pyx_PySendResult result, PyObject *retval, int iternext) { + CYTHON_MAYBE_UNUSED_VAR(gen); + if (likely(result == PYGEN_RETURN)) { + int is_async = 0; + #ifdef __Pyx_AsyncGen_USED + is_async = __Pyx_AsyncGen_CheckExact(gen); + #endif + __Pyx_ReturnWithStopIteration(retval, is_async, iternext); + Py_XDECREF(retval); + } + return NULL; + } + #if CYTHON_COMPILING_IN_CPYTHON + static CYTHON_INLINE + PyObject *__Pyx_PyGen_Send(PyGenObject *gen, PyObject *arg) { + #if PY_VERSION_HEX <= 0x030A00A1 + return _PyGen_Send(gen, arg); + #else + PyObject *result; + if (PyIter_Send((PyObject*)gen, arg ? arg : Py_None, &result) == PYGEN_RETURN) { + if (PyAsyncGen_CheckExact(gen)) { + assert(result == Py_None); + PyErr_SetNone(PyExc_StopAsyncIteration); + } + else if (result == Py_None) { + PyErr_SetNone(PyExc_StopIteration); + } + else { + #if PY_VERSION_HEX < 0x030d00A1 + _PyGen_SetStopIterationValue(result); + #else + if (!PyTuple_Check(result) && !PyExceptionInstance_Check(result)) { + PyErr_SetObject(PyExc_StopIteration, result); + } else { + PyObject *exc = __Pyx_PyObject_CallOneArg(PyExc_StopIteration, result); + if (likely(exc != NULL)) { + PyErr_SetObject(PyExc_StopIteration, exc); + Py_DECREF(exc); + } + } + #endif + } + Py_DECREF(result); + result = NULL; + } + return result; + #endif + } + #endif + static CYTHON_INLINE __Pyx_PySendResult + __Pyx_Coroutine_FinishDelegation(__pyx_CoroutineObject *gen, PyObject** retval) { + __Pyx_PySendResult result; + PyObject *val = NULL; + assert(__Pyx_Coroutine_get_is_running(gen)); + __Pyx_Coroutine_Undelegate(gen); + __Pyx_PyGen__FetchStopIterationValue(__Pyx_PyThreadState_Current, &val); + result = __Pyx_Coroutine_SendEx(gen, val, retval, 0); + Py_XDECREF(val); + return result; + } + #if CYTHON_USE_AM_SEND + static __Pyx_PySendResult + __Pyx_Coroutine_SendToDelegate(__pyx_CoroutineObject *gen, __Pyx_pyiter_sendfunc gen_am_send, PyObject *value, PyObject **retval) { + PyObject *ret = NULL; + __Pyx_PySendResult delegate_result, result; + assert(__Pyx_Coroutine_get_is_running(gen)); + delegate_result = gen_am_send(gen->yieldfrom, value, &ret); + if (delegate_result == PYGEN_NEXT) { + assert (ret != NULL); + *retval = ret; + return PYGEN_NEXT; + } + assert (delegate_result != PYGEN_ERROR || ret == NULL); + __Pyx_Coroutine_Undelegate(gen); + result = __Pyx_Coroutine_SendEx(gen, ret, retval, 0); + Py_XDECREF(ret); + return result; + } + #endif + static PyObject *__Pyx_Coroutine_Send(PyObject *self, PyObject *value) { + PyObject *retval = NULL; + __Pyx_PySendResult result = __Pyx_Coroutine_AmSend(self, value, &retval); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 0); + } + static __Pyx_PySendResult + __Pyx_Coroutine_AmSend(PyObject *self, PyObject *value, PyObject **retval) { + __Pyx_PySendResult result; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + *retval = __Pyx_Coroutine_AlreadyRunningError(gen); + return PYGEN_ERROR; + } + #if CYTHON_USE_AM_SEND + if (gen->yieldfrom_am_send) { + result = __Pyx_Coroutine_SendToDelegate(gen, gen->yieldfrom_am_send, value, retval); + } else + #endif + if (gen->yieldfrom) { + PyObject *yf = gen->yieldfrom; + PyObject *ret; + #if !CYTHON_USE_AM_SEND + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_Check(yf)) { + ret = __Pyx_Coroutine_Send(yf, value); + } else + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_PyAsyncGenASend_CheckExact(yf)) { + ret = __Pyx_async_gen_asend_send(yf, value); + } else + #endif + #if CYTHON_COMPILING_IN_CPYTHON + if (PyGen_CheckExact(yf)) { + ret = __Pyx_PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); + } else + if (PyCoro_CheckExact(yf)) { + ret = __Pyx_PyGen_Send((PyGenObject*)yf, value == Py_None ? NULL : value); + } else + #endif + #endif + { + #if !CYTHON_COMPILING_IN_LIMITED_API || __PYX_LIMITED_VERSION_HEX >= 0x03080000 + if (value == Py_None && PyIter_Check(yf)) + ret = __Pyx_PyIter_Next_Plain(yf); + else + #endif + ret = __Pyx_PyObject_CallMethod1(yf, __pyx_mstate_global->__pyx_n_u_send, value); + } + if (likely(ret)) { + __Pyx_Coroutine_unset_is_running(gen); + *retval = ret; + return PYGEN_NEXT; + } + result = __Pyx_Coroutine_FinishDelegation(gen, retval); + } else { + result = __Pyx_Coroutine_SendEx(gen, value, retval, 0); + } + __Pyx_Coroutine_unset_is_running(gen); + return result; + } + static int __Pyx_Coroutine_CloseIter(__pyx_CoroutineObject *gen, PyObject *yf) { + __Pyx_PySendResult result; + PyObject *retval = NULL; + CYTHON_UNUSED_VAR(gen); + assert(__Pyx_Coroutine_get_is_running(gen)); + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + result = __Pyx_Coroutine_Close(yf, &retval); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_Check(yf)) { + result = __Pyx_Coroutine_Close(yf, &retval); + } else + if (__Pyx_CoroutineAwait_CheckExact(yf)) { + result = __Pyx_CoroutineAwait_Close((__pyx_CoroutineAwaitObject*)yf); + } else + #endif + #ifdef __Pyx_AsyncGen_USED + if (__pyx_PyAsyncGenASend_CheckExact(yf)) { + retval = __Pyx_async_gen_asend_close(yf, NULL); + result = PYGEN_RETURN; + } else + if (__pyx_PyAsyncGenAThrow_CheckExact(yf)) { + retval = __Pyx_async_gen_athrow_close(yf, NULL); + result = PYGEN_RETURN; + } else + #endif + { + PyObject *meth; + result = PYGEN_RETURN; + meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_mstate_global->__pyx_n_u_close); + if (unlikely(!meth)) { + if (unlikely(PyErr_Occurred())) { + PyErr_WriteUnraisable(yf); + } + } else { + retval = __Pyx_PyObject_CallNoArg(meth); + Py_DECREF(meth); + if (unlikely(!retval)) { + result = PYGEN_ERROR; + } + } + } + Py_XDECREF(retval); + return result == PYGEN_ERROR ? -1 : 0; + } + static PyObject *__Pyx_Generator_Next(PyObject *self) { + __Pyx_PySendResult result; + PyObject *retval = NULL; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + return __Pyx_Coroutine_AlreadyRunningError(gen); + } + #if CYTHON_USE_AM_SEND + if (gen->yieldfrom_am_send) { + result = __Pyx_Coroutine_SendToDelegate(gen, gen->yieldfrom_am_send, Py_None, &retval); + } else + #endif + if (gen->yieldfrom) { + PyObject *yf = gen->yieldfrom; + PyObject *ret; + #ifdef __Pyx_Generator_USED + if (__Pyx_Generator_CheckExact(yf)) { + ret = __Pyx_Generator_Next(yf); + } else + #endif + #ifdef __Pyx_Coroutine_USED + if (__Pyx_Coroutine_CheckExact(yf)) { + ret = __Pyx_Coroutine_Send(yf, Py_None); + } else + #endif + #if CYTHON_COMPILING_IN_CPYTHON && (PY_VERSION_HEX < 0x030A00A3 || !CYTHON_USE_AM_SEND) + if (PyGen_CheckExact(yf)) { + ret = __Pyx_PyGen_Send((PyGenObject*)yf, NULL); + } else + #endif + ret = __Pyx_PyIter_Next_Plain(yf); + if (likely(ret)) { + __Pyx_Coroutine_unset_is_running(gen); + return ret; + } + result = __Pyx_Coroutine_FinishDelegation(gen, &retval); + } else { + result = __Pyx_Coroutine_SendEx(gen, Py_None, &retval, 0); + } + __Pyx_Coroutine_unset_is_running(gen); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 1); + } + static PyObject *__Pyx_Coroutine_Close_Method(PyObject *self, PyObject *arg) { + PyObject *retval = NULL; + __Pyx_PySendResult result; + CYTHON_UNUSED_VAR(arg); + result = __Pyx_Coroutine_Close(self, &retval); + if (unlikely(result == PYGEN_ERROR)) + return NULL; + Py_XDECREF(retval); + Py_RETURN_NONE; + } + static __Pyx_PySendResult + __Pyx_Coroutine_Close(PyObject *self, PyObject **retval) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + __Pyx_PySendResult result; + PyObject *yf; + int err = 0; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + *retval = __Pyx_Coroutine_AlreadyRunningError(gen); + return PYGEN_ERROR; + } + yf = gen->yieldfrom; + if (yf) { + Py_INCREF(yf); + err = __Pyx_Coroutine_CloseIter(gen, yf); + __Pyx_Coroutine_Undelegate(gen); + Py_DECREF(yf); + } + if (err == 0) + PyErr_SetNone(PyExc_GeneratorExit); + result = __Pyx_Coroutine_SendEx(gen, NULL, retval, 1); + if (result == PYGEN_ERROR) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_Coroutine_unset_is_running(gen); + if (!__Pyx_PyErr_Occurred()) { + return PYGEN_RETURN; + } else if (likely(__Pyx_PyErr_ExceptionMatches2(PyExc_GeneratorExit, PyExc_StopIteration))) { + __Pyx_PyErr_Clear(); + return PYGEN_RETURN; + } + return PYGEN_ERROR; + } else if (likely(result == PYGEN_RETURN && *retval == Py_None)) { + __Pyx_Coroutine_unset_is_running(gen); + return PYGEN_RETURN; + } else { + const char *msg; + Py_DECREF(*retval); + *retval = NULL; + if ((0)) { + #ifdef __Pyx_Coroutine_USED + } else if (__Pyx_Coroutine_Check(self)) { + msg = "coroutine ignored GeneratorExit"; + #endif + #ifdef __Pyx_AsyncGen_USED + } else if (__Pyx_AsyncGen_CheckExact(self)) { + msg = "async generator ignored GeneratorExit"; + #endif + } else { + msg = "generator ignored GeneratorExit"; + } + PyErr_SetString(PyExc_RuntimeError, msg); + __Pyx_Coroutine_unset_is_running(gen); + return PYGEN_ERROR; + } + } + static PyObject *__Pyx__Coroutine_Throw(PyObject *self, PyObject *typ, PyObject *val, PyObject *tb, + PyObject *args, int close_on_genexit) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject *yf; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) + return __Pyx_Coroutine_AlreadyRunningError(gen); + yf = gen->yieldfrom; + if (yf) { + __Pyx_PySendResult result; + PyObject *ret; + Py_INCREF(yf); + if (__Pyx_PyErr_GivenExceptionMatches(typ, PyExc_GeneratorExit) && close_on_genexit) { + int err = __Pyx_Coroutine_CloseIter(gen, yf); + Py_DECREF(yf); + __Pyx_Coroutine_Undelegate(gen); + if (err < 0) + goto propagate_exception; + goto throw_here; + } + if (0 + #ifdef __Pyx_Generator_USED + || __Pyx_Generator_CheckExact(yf) + #endif + #ifdef __Pyx_Coroutine_USED + || __Pyx_Coroutine_Check(yf) + #endif + ) { + ret = __Pyx__Coroutine_Throw(yf, typ, val, tb, args, close_on_genexit); + #ifdef __Pyx_Coroutine_USED + } else if (__Pyx_CoroutineAwait_CheckExact(yf)) { + ret = __Pyx__Coroutine_Throw(((__pyx_CoroutineAwaitObject*)yf)->coroutine, typ, val, tb, args, close_on_genexit); + #endif + } else { + PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(yf, __pyx_mstate_global->__pyx_n_u_throw); + if (unlikely(!meth)) { + Py_DECREF(yf); + if (unlikely(PyErr_Occurred())) { + __Pyx_Coroutine_unset_is_running(gen); + return NULL; + } + __Pyx_Coroutine_Undelegate(gen); + goto throw_here; + } + if (likely(args)) { + ret = __Pyx_PyObject_Call(meth, args, NULL); + } else { + PyObject *cargs[4] = {NULL, typ, val, tb}; + size_t nargs = 1U + (val != NULL) + (tb != NULL); + ret = __Pyx_PyObject_FastCall(meth, cargs+1, nargs | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); + } + Py_DECREF(meth); + } + Py_DECREF(yf); + if (ret) { + __Pyx_Coroutine_unset_is_running(gen); + return ret; + } + result = __Pyx_Coroutine_FinishDelegation(gen, &ret); + __Pyx_Coroutine_unset_is_running(gen); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, ret, 0); + } + throw_here: + __Pyx_Raise(typ, val, tb, NULL); + propagate_exception: + { + PyObject *retval = NULL; + __Pyx_PySendResult result = __Pyx_Coroutine_SendEx(gen, NULL, &retval, 0); + __Pyx_Coroutine_unset_is_running(gen); + return __Pyx_Coroutine_MethodReturnFromResult(self, result, retval, 0); + } + } + static PyObject *__Pyx_Coroutine_Throw(PyObject *self, PyObject *args) { + PyObject *typ; + PyObject *val = NULL; + PyObject *tb = NULL; + if (unlikely(!PyArg_UnpackTuple(args, "throw", 1, 3, &typ, &val, &tb))) + return NULL; + return __Pyx__Coroutine_Throw(self, typ, val, tb, args, 1); + } + static CYTHON_INLINE int __Pyx_Coroutine_traverse_excstate(__Pyx_ExcInfoStruct *exc_state, visitproc visit, void *arg) { + #if PY_VERSION_HEX >= 0x030B00a4 + Py_VISIT(exc_state->exc_value); + #else + Py_VISIT(exc_state->exc_type); + Py_VISIT(exc_state->exc_value); + Py_VISIT(exc_state->exc_traceback); + #endif + return 0; + } + static int __Pyx_Coroutine_traverse(__pyx_CoroutineObject *gen, visitproc visit, void *arg) { + { + int e = __Pyx_call_type_traverse((PyObject*)gen, 1, visit, arg); + if (e) return e; + } + Py_VISIT(gen->closure); + Py_VISIT(gen->classobj); + Py_VISIT(gen->yieldfrom); + return __Pyx_Coroutine_traverse_excstate(&gen->gi_exc_state, visit, arg); + } + static int __Pyx_Coroutine_clear(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + Py_CLEAR(gen->closure); + Py_CLEAR(gen->classobj); + __Pyx_Coroutine_Undelegate(gen); + __Pyx_Coroutine_ExceptionClear(&gen->gi_exc_state); + #ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(self)) { + Py_CLEAR(((__pyx_PyAsyncGenObject*)gen)->ag_finalizer); + } + #endif + Py_CLEAR(gen->gi_code); + Py_CLEAR(gen->gi_frame); + Py_CLEAR(gen->gi_name); + Py_CLEAR(gen->gi_qualname); + Py_CLEAR(gen->gi_modulename); + return 0; + } + static void __Pyx_Coroutine_dealloc(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + PyObject_GC_UnTrack(gen); + #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + if (gen->gi_weakreflist != NULL) + #endif + PyObject_ClearWeakRefs(self); + if (gen->resume_label >= 0) { + PyObject_GC_Track(self); + #if CYTHON_USE_TP_FINALIZE + if (unlikely(PyObject_CallFinalizerFromDealloc(self))) + #else + { + destructor del = __Pyx_PyObject_GetSlot(gen, tp_del, destructor); + if (del) del(self); + } + if (unlikely(Py_REFCNT(self) > 0)) + #endif + { + return; + } + PyObject_GC_UnTrack(self); + } + #ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(self)) { + /* We have to handle this case for asynchronous generators + right here, because this code has to be between UNTRACK + and GC_Del. */ + Py_CLEAR(((__pyx_PyAsyncGenObject*)self)->ag_finalizer); + } + #endif + __Pyx_Coroutine_clear(self); + __Pyx_PyHeapTypeObject_GC_Del(gen); + } + #if CYTHON_USE_TP_FINALIZE + static void __Pyx_Coroutine_del(PyObject *self) { + PyObject *error_type, *error_value, *error_traceback; + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject *) self; + __Pyx_PyThreadState_declare + if (gen->resume_label < 0) { + return; + } + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&error_type, &error_value, &error_traceback); + #ifdef __Pyx_AsyncGen_USED + if (__Pyx_AsyncGen_CheckExact(self)) { + __pyx_PyAsyncGenObject *agen = (__pyx_PyAsyncGenObject*)self; + PyObject *finalizer = agen->ag_finalizer; + if (finalizer && !agen->ag_closed) { + PyObject *res = __Pyx_PyObject_CallOneArg(finalizer, self); + if (unlikely(!res)) { + PyErr_WriteUnraisable(self); + } else { + Py_DECREF(res); + } + __Pyx_ErrRestore(error_type, error_value, error_traceback); + return; + } + } + #endif + if (unlikely(gen->resume_label == 0 && !error_value)) { + #ifdef __Pyx_Coroutine_USED + #ifdef __Pyx_Generator_USED + if (!__Pyx_Generator_CheckExact(self)) + #endif + { + PyObject_GC_UnTrack(self); + if (unlikely(PyErr_WarnFormat(PyExc_RuntimeWarning, 1, "coroutine '%.50S' was never awaited", gen->gi_qualname) < 0)) + PyErr_WriteUnraisable(self); + PyObject_GC_Track(self); + } + #endif + } else { + PyObject *retval = NULL; + __Pyx_PySendResult result = __Pyx_Coroutine_Close(self, &retval); + if (result == PYGEN_ERROR) { + PyErr_WriteUnraisable(self); + } else { + Py_XDECREF(retval); + } + } + __Pyx_ErrRestore(error_type, error_value, error_traceback); + } + #endif + static PyObject * + __Pyx_Coroutine_get_name(__pyx_CoroutineObject *self, void *context) + { + PyObject *name = self->gi_name; + CYTHON_UNUSED_VAR(context); + if (unlikely(!name)) name = Py_None; + Py_INCREF(name); + return name; + } + static int + __Pyx_Coroutine_set_name(__pyx_CoroutineObject *self, PyObject *value, void *context) + { + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(self->gi_name, value); + return 0; + } + static PyObject * + __Pyx_Coroutine_get_qualname(__pyx_CoroutineObject *self, void *context) + { + PyObject *name = self->gi_qualname; + CYTHON_UNUSED_VAR(context); + if (unlikely(!name)) name = Py_None; + Py_INCREF(name); + return name; + } + static int + __Pyx_Coroutine_set_qualname(__pyx_CoroutineObject *self, PyObject *value, void *context) + { + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_Py_XDECREF_SET(self->gi_qualname, value); + return 0; + } + #if !CYTHON_COMPILING_IN_LIMITED_API + static PyObject * + __Pyx__Coroutine_get_frame_locked(__pyx_CoroutineObject *self) { + PyObject *frame; + frame = self->gi_frame; + if (!frame) { + if (unlikely(!self->gi_code)) { + Py_RETURN_NONE; + } + PyObject *globals = PyDict_New(); + if (unlikely(!globals)) return NULL; + frame = (PyObject *) PyFrame_New( + PyThreadState_Get(), /*PyThreadState *tstate,*/ + (PyCodeObject*) self->gi_code, /*PyCodeObject *code,*/ + globals, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + Py_DECREF(globals); + if (unlikely(!frame)) + return NULL; + if (unlikely(self->gi_frame)) { + Py_DECREF(frame); + frame = self->gi_frame; + } else { + self->gi_frame = frame; + } + } + Py_INCREF(frame); + return frame; + } + #endif + static PyObject * + __Pyx__Coroutine_get_frame(__pyx_CoroutineObject *self) + { + #if !CYTHON_COMPILING_IN_LIMITED_API + PyObject *frame; + __Pyx_BEGIN_CRITICAL_SECTION((PyObject*)self); + frame = __Pyx__Coroutine_get_frame_locked(self); + __Pyx_END_CRITICAL_SECTION(); + return frame; + #else + CYTHON_UNUSED_VAR(self); + Py_RETURN_NONE; + #endif + } + static PyObject * + __Pyx_Coroutine_get_frame(__pyx_CoroutineObject *self, void *context) { + CYTHON_UNUSED_VAR(context); + PyObject *frame = self->gi_frame; + if (frame) + return __Pyx_NewRef(frame); + return __Pyx__Coroutine_get_frame(self); + } + static __pyx_CoroutineObject *__Pyx__Coroutine_New( + PyTypeObject* type, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name) { + __pyx_CoroutineObject *gen = PyObject_GC_New(__pyx_CoroutineObject, type); + if (unlikely(!gen)) + return NULL; + return __Pyx__Coroutine_NewInit(gen, body, code, closure, name, qualname, module_name); + } + static __pyx_CoroutineObject *__Pyx__Coroutine_NewInit( + __pyx_CoroutineObject *gen, __pyx_coroutine_body_t body, PyObject *code, PyObject *closure, + PyObject *name, PyObject *qualname, PyObject *module_name) { + gen->body = body; + gen->closure = closure; + Py_XINCREF(closure); + gen->is_running = 0; + gen->resume_label = 0; + gen->classobj = NULL; + gen->yieldfrom = NULL; + gen->yieldfrom_am_send = NULL; + #if PY_VERSION_HEX >= 0x030B00a4 && !CYTHON_COMPILING_IN_LIMITED_API + gen->gi_exc_state.exc_value = NULL; + #else + gen->gi_exc_state.exc_type = NULL; + gen->gi_exc_state.exc_value = NULL; + gen->gi_exc_state.exc_traceback = NULL; + #endif + #if CYTHON_USE_EXC_INFO_STACK + gen->gi_exc_state.previous_item = NULL; + #endif + #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + gen->gi_weakreflist = NULL; + #endif + Py_XINCREF(qualname); + gen->gi_qualname = qualname; + Py_XINCREF(name); + gen->gi_name = name; + Py_XINCREF(module_name); + gen->gi_modulename = module_name; + Py_XINCREF(code); + gen->gi_code = code; + gen->gi_frame = NULL; + #if CYTHON_USE_SYS_MONITORING && (CYTHON_PROFILE || CYTHON_TRACE) + memset(gen->__pyx_pymonitoring_state, 0, sizeof(gen->__pyx_pymonitoring_state)); + gen->__pyx_pymonitoring_version = 0; + #endif + PyObject_GC_Track(gen); + return gen; + } + static char __Pyx_Coroutine_test_and_set_is_running(__pyx_CoroutineObject *gen) { + char result; + __Pyx_BEGIN_CRITICAL_SECTION((PyObject*)gen); + result = gen->is_running; + gen->is_running = 1; + __Pyx_END_CRITICAL_SECTION(); + return result; + } + static void __Pyx_Coroutine_unset_is_running(__pyx_CoroutineObject *gen) { + __Pyx_BEGIN_CRITICAL_SECTION((PyObject*)gen); + assert(gen->is_running); + gen->is_running = 0; + __Pyx_END_CRITICAL_SECTION(); + } + static char __Pyx_Coroutine_get_is_running(__pyx_CoroutineObject *gen) { + char result; + __Pyx_BEGIN_CRITICAL_SECTION((PyObject*)gen); + result = gen->is_running; + __Pyx_END_CRITICAL_SECTION(); + return result; + } + static PyObject *__Pyx_Coroutine_get_is_running_getter(PyObject *gen, void *closure) { + CYTHON_UNUSED_VAR(closure); + char result = __Pyx_Coroutine_get_is_running((__pyx_CoroutineObject*)gen); + if (result) Py_RETURN_TRUE; + else Py_RETURN_FALSE; + } + #if __PYX_HAS_PY_AM_SEND == 2 + static void __Pyx_SetBackportTypeAmSend(PyTypeObject *type, __Pyx_PyAsyncMethodsStruct *static_amsend_methods, __Pyx_pyiter_sendfunc am_send) { + Py_ssize_t ptr_offset = (char*)(type->tp_as_async) - (char*)type; + if (ptr_offset < 0 || ptr_offset > type->tp_basicsize) { + return; + } + memcpy((void*)static_amsend_methods, (void*)(type->tp_as_async), sizeof(*type->tp_as_async)); + static_amsend_methods->am_send = am_send; + type->tp_as_async = __Pyx_SlotTpAsAsync(static_amsend_methods); + } + #endif + static PyObject *__Pyx_Coroutine_fail_reduce_ex(PyObject *self, PyObject *arg) { + CYTHON_UNUSED_VAR(arg); + __Pyx_TypeName self_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE((PyObject*)self)); + PyErr_Format(PyExc_TypeError, "cannot pickle '" __Pyx_FMT_TYPENAME "' object", + self_type_name); + __Pyx_DECREF_TypeName(self_type_name); + return NULL; + } + +/* Generator */ + static PyMethodDef __pyx_Generator_methods[] = { + {"send", (PyCFunction) __Pyx_Coroutine_Send, METH_O, + PyDoc_STR("send(arg) -> send 'arg' into generator,\nreturn next yielded value or raise StopIteration.")}, + {"throw", (PyCFunction) __Pyx_Coroutine_Throw, METH_VARARGS, + PyDoc_STR("throw(typ[,val[,tb]]) -> raise exception in generator,\nreturn next yielded value or raise StopIteration.")}, + {"close", (PyCFunction) __Pyx_Coroutine_Close_Method, METH_NOARGS, + PyDoc_STR("close() -> raise GeneratorExit inside generator.")}, + {"__reduce_ex__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_O, 0}, + {"__reduce__", (PyCFunction) __Pyx_Coroutine_fail_reduce_ex, METH_NOARGS, 0}, + {0, 0, 0, 0} + }; + static PyMemberDef __pyx_Generator_memberlist[] = { + {"gi_yieldfrom", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY, + PyDoc_STR("object being iterated by 'yield from', or None")}, + {"gi_code", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_code), READONLY, NULL}, + {"__module__", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_modulename), 0, 0}, + #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CoroutineObject, gi_weakreflist), READONLY, 0}, + #endif + {0, 0, 0, 0, 0} + }; + static PyGetSetDef __pyx_Generator_getsets[] = { + {"__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name, + PyDoc_STR("name of the generator"), 0}, + {"__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname, + PyDoc_STR("qualified name of the generator"), 0}, + {"gi_frame", (getter)__Pyx_Coroutine_get_frame, NULL, + PyDoc_STR("Frame of the generator"), 0}, + {"gi_running", __Pyx_Coroutine_get_is_running_getter, NULL, NULL, NULL}, + {0, 0, 0, 0, 0} + }; + static PyType_Slot __pyx_GeneratorType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_Coroutine_dealloc}, + {Py_tp_traverse, (void *)__Pyx_Coroutine_traverse}, + {Py_tp_iter, (void *)PyObject_SelfIter}, + {Py_tp_iternext, (void *)__Pyx_Generator_Next}, + {Py_tp_methods, (void *)__pyx_Generator_methods}, + {Py_tp_members, (void *)__pyx_Generator_memberlist}, + {Py_tp_getset, (void *)__pyx_Generator_getsets}, + {Py_tp_getattro, (void *) PyObject_GenericGetAttr}, + #if CYTHON_USE_TP_FINALIZE + {Py_tp_finalize, (void *)__Pyx_Coroutine_del}, + #endif + #if __PYX_HAS_PY_AM_SEND == 1 + {Py_am_send, (void *)__Pyx_Coroutine_AmSend}, + #endif + {0, 0}, + }; + static PyType_Spec __pyx_GeneratorType_spec = { + __PYX_TYPE_MODULE_PREFIX "generator", + sizeof(__pyx_CoroutineObject), + 0, + #if PY_VERSION_HEX >= 0x030C0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_TPFLAGS_MANAGED_WEAKREF | + #endif + Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION | + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | __Pyx_TPFLAGS_HAVE_AM_SEND, + __pyx_GeneratorType_slots + }; + #if __PYX_HAS_PY_AM_SEND == 2 + static __Pyx_PyAsyncMethodsStruct __pyx_Generator_as_async; + #endif + static int __pyx_Generator_init(PyObject *module) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + mstate->__pyx_GeneratorType = __Pyx_FetchCommonTypeFromSpec( + mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_GeneratorType_spec, NULL); + if (unlikely(!mstate->__pyx_GeneratorType)) { + return -1; + } + #if __PYX_HAS_PY_AM_SEND == 2 + __Pyx_SetBackportTypeAmSend(mstate->__pyx_GeneratorType, &__pyx_Generator_as_async, &__Pyx_Coroutine_AmSend); + #endif + return 0; + } + static PyObject *__Pyx_Generator_GetInlinedResult(PyObject *self) { + __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*) self; + PyObject *retval = NULL; + if (unlikely(__Pyx_Coroutine_test_and_set_is_running(gen))) { + return __Pyx_Coroutine_AlreadyRunningError(gen); + } + __Pyx_PySendResult result = __Pyx_Coroutine_SendEx(gen, Py_None, &retval, 0); + __Pyx_Coroutine_unset_is_running(gen); + (void) result; + assert (result == PYGEN_RETURN || result == PYGEN_ERROR); + assert ((result == PYGEN_RETURN && retval != NULL) || (result == PYGEN_ERROR && retval == NULL)); + return retval; + } + +/* CheckBinaryVersion */ + static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { + const unsigned long MAJOR_MINOR = 0xFFFF0000UL; + if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) + return 0; + if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) + return 1; + { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compile time Python version %d.%d " + "of module '%.100s' " + "%s " + "runtime version %d.%d", + (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), + __Pyx_MODULE_NAME, + (allow_newer) ? "was newer than" : "does not match", + (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) + ); + return PyErr_WarnEx(NULL, message, 1); + } + } + +/* NewCodeObj */ + #if CYTHON_COMPILING_IN_LIMITED_API + static PyObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyObject *exception_table = NULL; + PyObject *types_module=NULL, *code_type=NULL, *result=NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + PyObject *version_info; + PyObject *py_minor_version = NULL; + #endif + long minor_version = 0; + PyObject *type, *value, *traceback; + PyErr_Fetch(&type, &value, &traceback); + #if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOOOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); + } + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); + if (type) { + PyErr_Restore(type, value, traceback); + } + return result; + } + #elif PY_VERSION_HEX >= 0x030B0000 + static PyCodeObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, __pyx_mstate_global->__pyx_empty_bytes); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030c00A1 + if (likely(result)) + result->_co_firsttraceable = 0; + #endif + return result; + } + #elif !CYTHON_COMPILING_IN_PYPY + #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #else + #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #endif + static PyObject* __Pyx_PyCode_New( + const __Pyx_PyCode_New_function_description descr, + PyObject * const *varnames, + PyObject *filename, + PyObject *funcname, + PyObject *line_table, + PyObject *tuple_dedup_map + ) { + PyObject *code_obj = NULL, *varnames_tuple_dedup = NULL, *code_bytes = NULL; + Py_ssize_t var_count = (Py_ssize_t) descr.nlocals; + PyObject *varnames_tuple = PyTuple_New(var_count); + if (unlikely(!varnames_tuple)) return NULL; + for (Py_ssize_t i=0; i < var_count; i++) { + Py_INCREF(varnames[i]); + if (__Pyx_PyTuple_SET_ITEM(varnames_tuple, i, varnames[i]) != (0)) goto done; + } + #if CYTHON_COMPILING_IN_LIMITED_API + varnames_tuple_dedup = PyDict_GetItem(tuple_dedup_map, varnames_tuple); + if (!varnames_tuple_dedup) { + if (unlikely(PyDict_SetItem(tuple_dedup_map, varnames_tuple, varnames_tuple) < 0)) goto done; + varnames_tuple_dedup = varnames_tuple; + } + #else + varnames_tuple_dedup = PyDict_SetDefault(tuple_dedup_map, varnames_tuple, varnames_tuple); + if (unlikely(!varnames_tuple_dedup)) goto done; + #endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(varnames_tuple_dedup); + #endif + if (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table != NULL && !CYTHON_COMPILING_IN_GRAAL) { + Py_ssize_t line_table_length = __Pyx_PyBytes_GET_SIZE(line_table); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(line_table_length == -1)) goto done; + #endif + Py_ssize_t code_len = (line_table_length * 2 + 4) & ~3LL; + code_bytes = PyBytes_FromStringAndSize(NULL, code_len); + if (unlikely(!code_bytes)) goto done; + char* c_code_bytes = PyBytes_AsString(code_bytes); + if (unlikely(!c_code_bytes)) goto done; + memset(c_code_bytes, 0, (size_t) code_len); + } + code_obj = (PyObject*) __Pyx__PyCode_New( + (int) descr.argcount, + (int) descr.num_posonly_args, + (int) descr.num_kwonly_args, + (int) descr.nlocals, + 0, + (int) descr.flags, + code_bytes ? code_bytes : __pyx_mstate_global->__pyx_empty_bytes, + __pyx_mstate_global->__pyx_empty_tuple, + __pyx_mstate_global->__pyx_empty_tuple, + varnames_tuple_dedup, + __pyx_mstate_global->__pyx_empty_tuple, + __pyx_mstate_global->__pyx_empty_tuple, + filename, + funcname, + (int) descr.first_line, + (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table) ? line_table : __pyx_mstate_global->__pyx_empty_bytes + ); + done: + Py_XDECREF(code_bytes); + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(varnames_tuple_dedup); + #endif + Py_DECREF(varnames_tuple); + return code_obj; + } + +/* DecompressString */ + static PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int algo) { + PyObject *module = NULL, *decompress, *compressed_bytes, *decompressed; + const char* module_name = algo == 3 ? "compression.zstd" : algo == 2 ? "bz2" : "zlib"; + PyObject *methodname = PyUnicode_FromString("decompress"); + if (unlikely(!methodname)) return NULL; + #if __PYX_LIMITED_VERSION_HEX >= 0x030e0000 + if (algo == 3) { + PyObject *fromlist = Py_BuildValue("[O]", methodname); + if (unlikely(!fromlist)) goto bad; + module = PyImport_ImportModuleLevel("compression.zstd", NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + } else + #endif + module = PyImport_ImportModule(module_name); + if (unlikely(!module)) goto import_failed; + decompress = PyObject_GetAttr(module, methodname); + if (unlikely(!decompress)) goto import_failed; + { + #ifdef __cplusplus + char *memview_bytes = const_cast(s); + #else + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wcast-qual" + #elif !defined(__INTEL_COMPILER) && defined(__GNUC__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wcast-qual" + #endif + char *memview_bytes = (char*) s; + #if defined(__clang__) + #pragma clang diagnostic pop + #elif !defined(__INTEL_COMPILER) && defined(__GNUC__) + #pragma GCC diagnostic pop + #endif + #endif + #if CYTHON_COMPILING_IN_LIMITED_API && !defined(PyBUF_READ) + int memview_flags = 0x100; + #else + int memview_flags = PyBUF_READ; + #endif + compressed_bytes = PyMemoryView_FromMemory(memview_bytes, length, memview_flags); + } + if (unlikely(!compressed_bytes)) { + Py_DECREF(decompress); + goto bad; + } + decompressed = PyObject_CallFunctionObjArgs(decompress, compressed_bytes, NULL); + Py_DECREF(compressed_bytes); + Py_DECREF(decompress); + Py_DECREF(module); + Py_DECREF(methodname); + return decompressed; + import_failed: + PyErr_Format(PyExc_ImportError, + "Failed to import '%.20s.decompress' - cannot initialise module strings. " + "String compression was configured with the C macro 'CYTHON_COMPRESS_STRINGS=%d'.", + module_name, algo); + bad: + Py_XDECREF(module); + Py_DECREF(methodname); + return NULL; + } + +#include +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { + size_t len = strlen(s); + if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, "byte string is too long"); + return -1; + } + return (Py_ssize_t) len; +} +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return __Pyx_PyUnicode_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return PyByteArray_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + { + const char* result; + Py_ssize_t unicode_length; + CYTHON_MAYBE_UNUSED_VAR(unicode_length); // only for __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 + if (unlikely(PyArg_Parse(o, "s#", &result, length) < 0)) return NULL; + #else + result = PyUnicode_AsUTF8AndSize(o, length); + #endif + #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + unicode_length = PyUnicode_GetLength(o); + if (unlikely(unicode_length < 0)) return NULL; + if (unlikely(unicode_length != *length)) { + PyUnicode_AsASCIIString(o); + return NULL; + } + #endif + return result; + } +#else +#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_UTF8 + if (PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif + if (PyByteArray_Check(o)) { +#if (CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) || (CYTHON_COMPILING_IN_PYPY && (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))) + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); +#else + *length = PyByteArray_Size(o); + if (*length == -1) return NULL; + return PyByteArray_AsString(o); +#endif + } else + { + 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_LongWrongResultType(PyObject* result) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(result)); + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { + __Pyx_DECREF_TypeName(result_type_name); + Py_DECREF(result); + return NULL; + } + __Pyx_DECREF_TypeName(result_type_name); + return result; + } + PyErr_Format(PyExc_TypeError, + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ")", + result_type_name); + __Pyx_DECREF_TypeName(result_type_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + PyObject *res = NULL; + if (likely(PyLong_Check(x))) + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + if (likely(m && m->nb_int)) { + res = m->nb_int(x); + } +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Long(x); + } +#endif + if (likely(res)) { + if (unlikely(!PyLong_CheckExact(res))) { + return __Pyx_PyNumber_LongWrongResultType(res); + } + } + 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 (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(__Pyx_PyLong_IsCompact(b))) { + return __Pyx_PyLong_CompactValue(b); + } else { + const digit* digits = __Pyx_PyLong_Digits(b); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + 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 = PyLong_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); + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyLong_AsLong(x); + Py_DECREF(x); + return ival; + } +} +static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b) { + CYTHON_UNUSED_VAR(b); + return __Pyx_NewRef(Py_None); +} +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return __Pyx_NewRef(b ? Py_True: Py_False); +} +static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t ival) { + return PyLong_FromSize_t(ival); +} + + + /* MultiPhaseInitModuleState */ + #if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE + #ifndef CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + #if (CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX >= 0x030C0000) + #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 1 + #else + #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 0 + #endif + #endif + #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE && !CYTHON_ATOMICS + #error "Module state with PEP489 requires atomics. Currently that's one of\ + C11, C++11, gcc atomic intrinsics or MSVC atomic intrinsics" + #endif + #if !CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + #define __Pyx_ModuleStateLookup_Lock() + #define __Pyx_ModuleStateLookup_Unlock() + #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 + static PyMutex __Pyx_ModuleStateLookup_mutex = {0}; + #define __Pyx_ModuleStateLookup_Lock() PyMutex_Lock(&__Pyx_ModuleStateLookup_mutex) + #define __Pyx_ModuleStateLookup_Unlock() PyMutex_Unlock(&__Pyx_ModuleStateLookup_mutex) + #elif defined(__cplusplus) && __cplusplus >= 201103L + #include + static std::mutex __Pyx_ModuleStateLookup_mutex; + #define __Pyx_ModuleStateLookup_Lock() __Pyx_ModuleStateLookup_mutex.lock() + #define __Pyx_ModuleStateLookup_Unlock() __Pyx_ModuleStateLookup_mutex.unlock() + #elif defined(__STDC_VERSION__) && (__STDC_VERSION__ > 201112L) && !defined(__STDC_NO_THREADS__) + #include + static mtx_t __Pyx_ModuleStateLookup_mutex; + static once_flag __Pyx_ModuleStateLookup_mutex_once_flag = ONCE_FLAG_INIT; + static void __Pyx_ModuleStateLookup_initialize_mutex(void) { + mtx_init(&__Pyx_ModuleStateLookup_mutex, mtx_plain); + } + #define __Pyx_ModuleStateLookup_Lock()\ + call_once(&__Pyx_ModuleStateLookup_mutex_once_flag, __Pyx_ModuleStateLookup_initialize_mutex);\ + mtx_lock(&__Pyx_ModuleStateLookup_mutex) + #define __Pyx_ModuleStateLookup_Unlock() mtx_unlock(&__Pyx_ModuleStateLookup_mutex) + #elif defined(HAVE_PTHREAD_H) + #include + static pthread_mutex_t __Pyx_ModuleStateLookup_mutex = PTHREAD_MUTEX_INITIALIZER; + #define __Pyx_ModuleStateLookup_Lock() pthread_mutex_lock(&__Pyx_ModuleStateLookup_mutex) + #define __Pyx_ModuleStateLookup_Unlock() pthread_mutex_unlock(&__Pyx_ModuleStateLookup_mutex) + #elif defined(_WIN32) + #include // synchapi.h on its own doesn't work + static SRWLOCK __Pyx_ModuleStateLookup_mutex = SRWLOCK_INIT; + #define __Pyx_ModuleStateLookup_Lock() AcquireSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) + #define __Pyx_ModuleStateLookup_Unlock() ReleaseSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) + #else + #error "No suitable lock available for CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE.\ + Requires C standard >= C11, or C++ standard >= C++11,\ + or pthreads, or the Windows 32 API, or Python >= 3.13." + #endif + typedef struct { + int64_t id; + PyObject *module; + } __Pyx_InterpreterIdAndModule; + typedef struct { + char interpreter_id_as_index; + Py_ssize_t count; + Py_ssize_t allocated; + __Pyx_InterpreterIdAndModule table[1]; + } __Pyx_ModuleStateLookupData; + #define __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE 32 + #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + static __pyx_atomic_int_type __Pyx_ModuleStateLookup_read_counter = 0; + #endif + #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + static __pyx_atomic_ptr_type __Pyx_ModuleStateLookup_data = 0; + #else + static __Pyx_ModuleStateLookupData* __Pyx_ModuleStateLookup_data = NULL; + #endif + static __Pyx_InterpreterIdAndModule* __Pyx_State_FindModuleStateLookupTableLowerBound( + __Pyx_InterpreterIdAndModule* table, + Py_ssize_t count, + int64_t interpreterId) { + __Pyx_InterpreterIdAndModule* begin = table; + __Pyx_InterpreterIdAndModule* end = begin + count; + if (begin->id == interpreterId) { + return begin; + } + while ((end - begin) > __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + __Pyx_InterpreterIdAndModule* halfway = begin + (end - begin)/2; + if (halfway->id == interpreterId) { + return halfway; + } + if (halfway->id < interpreterId) { + begin = halfway; + } else { + end = halfway; + } + } + for (; begin < end; ++begin) { + if (begin->id >= interpreterId) return begin; + } + return begin; + } + static PyObject *__Pyx_State_FindModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return NULL; + #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData* data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + { + __pyx_atomic_incr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + if (likely(data)) { + __Pyx_ModuleStateLookupData* new_data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_acquire(&__Pyx_ModuleStateLookup_data); + if (likely(data == new_data)) { + goto read_finished; + } + } + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + __Pyx_ModuleStateLookup_Lock(); + __pyx_atomic_incr_relaxed(&__Pyx_ModuleStateLookup_read_counter); + data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + __Pyx_ModuleStateLookup_Unlock(); + } + read_finished:; + #else + __Pyx_ModuleStateLookupData* data = __Pyx_ModuleStateLookup_data; + #endif + __Pyx_InterpreterIdAndModule* found = NULL; + if (unlikely(!data)) goto end; + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + found = data->table+interpreter_id; + } + } else { + found = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + } + end: + { + PyObject *result=NULL; + if (found && found->id == interpreter_id) { + result = found->module; + } + #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + #endif + return result; + } + } + #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + static void __Pyx_ModuleStateLookup_wait_until_no_readers(void) { + while (__pyx_atomic_load(&__Pyx_ModuleStateLookup_read_counter) != 0); + } + #else + #define __Pyx_ModuleStateLookup_wait_until_no_readers() + #endif + static int __Pyx_State_AddModuleInterpIdAsIndex(__Pyx_ModuleStateLookupData **old_data, PyObject* module, int64_t interpreter_id) { + Py_ssize_t to_allocate = (*old_data)->allocated; + while (to_allocate <= interpreter_id) { + if (to_allocate == 0) to_allocate = 1; + else to_allocate *= 2; + } + __Pyx_ModuleStateLookupData *new_data = *old_data; + if (to_allocate != (*old_data)->allocated) { + new_data = (__Pyx_ModuleStateLookupData *)realloc( + *old_data, + sizeof(__Pyx_ModuleStateLookupData)+(to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + PyErr_NoMemory(); + return -1; + } + for (Py_ssize_t i = new_data->allocated; i < to_allocate; ++i) { + new_data->table[i].id = i; + new_data->table[i].module = NULL; + } + new_data->allocated = to_allocate; + } + new_data->table[interpreter_id].module = module; + if (new_data->count < interpreter_id+1) { + new_data->count = interpreter_id+1; + } + *old_data = new_data; + return 0; + } + static void __Pyx_State_ConvertFromInterpIdAsIndex(__Pyx_ModuleStateLookupData *data) { + __Pyx_InterpreterIdAndModule *read = data->table; + __Pyx_InterpreterIdAndModule *write = data->table; + __Pyx_InterpreterIdAndModule *end = read + data->count; + for (; readmodule) { + write->id = read->id; + write->module = read->module; + ++write; + } + } + data->count = write - data->table; + for (; writeid = 0; + write->module = NULL; + } + data->interpreter_id_as_index = 0; + } + static int __Pyx_State_AddModule(PyObject* module, CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + int result = 0; + __Pyx_ModuleStateLookup_Lock(); + #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *old_data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); + #else + __Pyx_ModuleStateLookupData *old_data = __Pyx_ModuleStateLookup_data; + #endif + __Pyx_ModuleStateLookupData *new_data = old_data; + if (!new_data) { + new_data = (__Pyx_ModuleStateLookupData *)calloc(1, sizeof(__Pyx_ModuleStateLookupData)); + if (!new_data) { + result = -1; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = 1; + new_data->interpreter_id_as_index = 1; + } + __Pyx_ModuleStateLookup_wait_until_no_readers(); + if (new_data->interpreter_id_as_index) { + if (interpreter_id < __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + result = __Pyx_State_AddModuleInterpIdAsIndex(&new_data, module, interpreter_id); + goto end; + } + __Pyx_State_ConvertFromInterpIdAsIndex(new_data); + } + { + Py_ssize_t insert_at = 0; + { + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + new_data->table, new_data->count, interpreter_id); + assert(lower_bound); + insert_at = lower_bound - new_data->table; + if (unlikely(insert_at < new_data->count && lower_bound->id == interpreter_id)) { + lower_bound->module = module; + goto end; // already in table, nothing more to do + } + } + if (new_data->count+1 >= new_data->allocated) { + Py_ssize_t to_allocate = (new_data->count+1)*2; + new_data = + (__Pyx_ModuleStateLookupData*)realloc( + new_data, + sizeof(__Pyx_ModuleStateLookupData) + + (to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + result = -1; + new_data = old_data; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = to_allocate; + } + ++new_data->count; + int64_t last_id = interpreter_id; + PyObject *last_module = module; + for (Py_ssize_t i=insert_at; icount; ++i) { + int64_t current_id = new_data->table[i].id; + new_data->table[i].id = last_id; + last_id = current_id; + PyObject *current_module = new_data->table[i].module; + new_data->table[i].module = last_module; + last_module = current_module; + } + } + end: + #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, new_data); + #else + __Pyx_ModuleStateLookup_data = new_data; + #endif + __Pyx_ModuleStateLookup_Unlock(); + return result; + } + static int __Pyx_State_RemoveModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + __Pyx_ModuleStateLookup_Lock(); + #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); + #else + __Pyx_ModuleStateLookupData *data = __Pyx_ModuleStateLookup_data; + #endif + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + data->table[interpreter_id].module = NULL; + } + goto done; + } + { + __Pyx_ModuleStateLookup_wait_until_no_readers(); + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + if (!lower_bound) goto done; + if (lower_bound->id != interpreter_id) goto done; + __Pyx_InterpreterIdAndModule *end = data->table+data->count; + for (;lower_boundid = (lower_bound+1)->id; + lower_bound->module = (lower_bound+1)->module; + } + } + --data->count; + if (data->count == 0) { + free(data); + data = NULL; + } + done: + #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, data); + #else + __Pyx_ModuleStateLookup_data = data; + #endif + __Pyx_ModuleStateLookup_Unlock(); + return 0; + } + #endif + +/* #### Code section: utility_code_pragmas_end ### */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + + + +/* #### Code section: end ### */ +#endif /* Py_PYTHON_H */ diff --git a/src/blokus_gym/core/blokus_cython.cpython-312-x86_64-linux-gnu.so b/src/blokus_gym/core/blokus_cython.cpython-312-x86_64-linux-gnu.so new file mode 100755 index 0000000000000000000000000000000000000000..71661367d673fc6a70c9aa3c1ae147e587fc288d GIT binary patch literal 513456 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
  • 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 None: + """Reset the board to empty.""" + self.grid.fill(0) + + def is_empty(self, int x, int y) -> bool: + """Check if a cell is empty (C-level fast).""" + cdef cnp.int8_t[:, :] grid_view = self.grid + cdef int size = self.size + + if 0 <= x < size and 0 <= y < size: + return grid_view[y, x] == 0 + return False + + def in_bounds(self, int x, int y) -> bool: + """Check if coordinates are within the board (C-level fast).""" + cdef int size = self.size + return 0 <= x < size and 0 <= y < size + + def has_overlap(self, list squares) -> bool: + """Check if any square is already occupied (C-level fast).""" + cdef int x, y + cdef cnp.int8_t[:, :] grid_view = self.grid + cdef int size = self.size + + for x, y in squares: + if not (0 <= x < size and 0 <= y < size) or grid_view[y, x] != 0: + return True + return False + + cdef bint is_cell_empty(self, int x, int y): + """Check if a cell is empty (C-level fast, inlineable).""" + cdef cnp.int8_t[:, :] grid_view = self.grid + cdef int size = self.size + + return 0 <= x < size and 0 <= y < size and grid_view[y, x] == 0 + + def get_cell(self, int x, int y) -> int: + """Get the player index at a cell (0 = empty).""" + cdef cnp.int8_t[:, :] grid_view = self.grid + cdef int size = self.size + + if 0 <= x < size and 0 <= y < size: + return grid_view[y, x] + return 0 + + def get_player_squares(self, int player_idx) -> list: + """Get all squares occupied by a player.""" + cdef cnp.int8_t[:, :] grid_view = self.grid + cdef int size = self.size + cdef list result = [] + cdef int x, y + + for y in range(size): + for x in range(size): + if grid_view[y, x] == player_idx: + result.append((x, y)) + return result + + def get_player_occupied(self, int player_idx) -> set: + """Get all squares occupied by a player as a set.""" + if player_idx not in self._occupied_cache: + self._occupied_cache[player_idx] = set(self.get_player_squares(player_idx)) + return self._occupied_cache[player_idx] + + def get_player_corners(self, int player_idx) -> set: + """Get all corner cells adjacent to a player's pieces.""" + cdef cnp.int8_t[:, :] grid_view = self.grid + cdef int size = self.size + cdef set corners = set() + cdef list player_squares = self.get_player_squares(player_idx) + cdef int x, y, dx, dy, cx, cy + + for x, y in player_squares: + for dx, dy in [(-1, -1), (1, -1), (-1, 1), (1, 1)]: + cx, cy = x + dx, y + dy + if 0 <= cx < size and 0 <= cy < size and grid_view[cy, cx] == 0: + corners.add((cx, cy)) + return corners + + def get_occupied(self) -> set: + """Get all occupied cells.""" + cdef cnp.int8_t[:, :] grid_view = self.grid + cdef int size = self.size + cdef set result = set() + cdef int x, y + + for y in range(size): + for x in range(size): + if grid_view[y, x] != 0: + result.add((x, y)) + return result + + def is_full(self) -> bool: + """Check if the board is completely full.""" + cdef cnp.int8_t[:, :] grid_view = self.grid + cdef int size = self.size + cdef int x, y + + for y in range(size): + for x in range(size): + if grid_view[y, x] == 0: + return False + return True + + def coverage(self) -> float: + """Get the fraction of the board that is occupied.""" + cdef cnp.int8_t[:, :] grid_view = self.grid + cdef int size = self.size + cdef int count = 0 + cdef int x, y + + for y in range(size): + for x in range(size): + if grid_view[y, x] != 0: + count += 1 + return count / (size * size) + + +# ------------------------------------------------------------------- +# Move and Piece classes +# ------------------------------------------------------------------- + +cdef class Move: + """A move in the game (piece, orientation, position).""" + + cdef public int piece_id + cdef public int orientation_id + cdef public int x + cdef public int y + + def __init__(self, int piece_id, int orientation_id, int x, int y): + self.piece_id = piece_id + self.orientation_id = orientation_id + self.x = x + self.y = y + + def __repr__(self): + return f"Move(piece={self.piece_id}, orient={self.orientation_id}, pos=({self.x}, {self.y}))" + + +cdef class PieceOrientation: + """A piece in a specific orientation (before placement on board).""" + + cdef public int piece_id + cdef public int orientation_id + cdef public list squares + cdef public list corners + + def __init__(self, int piece_id, int orientation_id, list squares, list corners): + self.piece_id = piece_id + self.orientation_id = orientation_id + self.squares = squares + self.corners = corners + + +cdef class Piece: + """A polyomino piece defined by a set of (x, y) coordinates.""" + + cdef public str name + cdef public object squares # Use object to allow frozenset + + def __init__(self, str name, object squares): + self.name = name + self.squares = squares + + @property + def size(self) -> int: + return len(self.squares) + + +cdef class PieceSet: + """A collection of pieces with pre-computed orientations.""" + + cdef public list pieces + cdef public list piece_names + cdef public dict piece_id_map + cdef public list orientations + cdef public int num_orientations + + def __init__(self, list pieces_list): + self.pieces = pieces_list + self.piece_names = [p.name for p in pieces_list] + self.piece_id_map = {name: i for i, name in enumerate(self.piece_names)} + + # Pre-compute all orientations for each piece + self.orientations = [] + for piece_id, piece in enumerate(pieces_list): + orients = generate_orientations_cython(piece) + for orient in orients: + orient.piece_id = piece_id + self.orientations.append(orients) + + self.num_orientations = sum(len(o) for o in self.orientations) + + @property + def num_pieces(self) -> int: + return len(self.pieces) + + def get_orientations(self, int piece_id) -> list: + return self.orientations[piece_id] + + def get_piece(self, int piece_id) -> Piece: + return self.pieces[piece_id] + + def get_piece_id(self, str name) -> int: + return self.piece_id_map[name] + + +# ------------------------------------------------------------------- +# Pre-computed standard pieces (Cython-optimized) +# ------------------------------------------------------------------- + +cdef frozenset _I1_squares = frozenset([(0, 0)]) +cdef frozenset _I2_squares = frozenset([(0, 0), (0, 1)]) +cdef frozenset _I3_squares = frozenset([(0, 0), (0, 1), (0, 2)]) +cdef frozenset _V3_squares = frozenset([(0, 0), (1, 0), (0, 1)]) +cdef frozenset _I4_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3)]) +cdef frozenset _L4_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0)]) +cdef frozenset _T4_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1)]) +cdef frozenset _S4_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1)]) +cdef frozenset _O4_squares = frozenset([(0, 0), (1, 0), (0, 1), (1, 1)]) +cdef frozenset _I5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (0, 4)]) +cdef frozenset _L5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 0)]) +cdef frozenset _Y5_squares = frozenset([(0, 0), (0, 1), (0, 2), (0, 3), (1, 1)]) +cdef frozenset _N5_squares = frozenset([(0, 0), (1, 0), (2, 0), (2, 1), (3, 1)]) +cdef frozenset _T5_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1), (1, 2)]) +cdef frozenset _U5_squares = frozenset([(0, 0), (2, 0), (0, 1), (1, 1), (2, 1)]) +cdef frozenset _V5_squares = frozenset([(0, 0), (0, 1), (0, 2), (1, 0), (2, 0)]) +cdef frozenset _W5_squares = frozenset([(0, 0), (0, 1), (1, 0), (1, 1), (2, 0)]) +cdef frozenset _Z5_squares = frozenset([(0, 0), (1, 0), (1, 1), (1, 2), (2, 2)]) +cdef frozenset _F5_squares = frozenset([(0, 0), (1, 0), (1, 1), (2, 1), (1, 2)]) +cdef frozenset _X5_squares = frozenset([(0, 0), (1, 0), (2, 0), (1, 1), (1, -1)]) +cdef frozenset _P5_squares = frozenset([(0, 0), (1, 0), (0, 1), (1, 1), (0, 2)]) + +cdef Piece _I1 = Piece("I1", _I1_squares) +cdef Piece _I2 = Piece("I2", _I2_squares) +cdef Piece _I3 = Piece("I3", _I3_squares) +cdef Piece _V3 = Piece("V3", _V3_squares) +cdef Piece _I4 = Piece("I4", _I4_squares) +cdef Piece _L4 = Piece("L4", _L4_squares) +cdef Piece _T4 = Piece("T4", _T4_squares) +cdef Piece _S4 = Piece("S4", _S4_squares) +cdef Piece _O4 = Piece("O4", _O4_squares) +cdef Piece _I5 = Piece("I5", _I5_squares) +cdef Piece _L5 = Piece("L5", _L5_squares) +cdef Piece _Y5 = Piece("Y5", _Y5_squares) +cdef Piece _N5 = Piece("N5", _N5_squares) +cdef Piece _T5 = Piece("T5", _T5_squares) +cdef Piece _U5 = Piece("U5", _U5_squares) +cdef Piece _V5 = Piece("V5", _V5_squares) +cdef Piece _W5 = Piece("W5", _W5_squares) +cdef Piece _Z5 = Piece("Z5", _Z5_squares) +cdef Piece _F5 = Piece("F5", _F5_squares) +cdef Piece _X5 = Piece("X5", _X5_squares) +cdef Piece _P5 = Piece("P5", _P5_squares) + +cdef list STANDARD_PIECES = [ + _I1, _I2, _I3, _V3, _I4, _L4, _T4, _S4, _O4, + _I5, _L5, _Y5, _N5, _T5, _U5, _V5, _W5, _Z5, _F5, _X5, _P5 +] + + +# ------------------------------------------------------------------- +# Orientation generation +# ------------------------------------------------------------------- + +cdef list generate_orientations_cython(Piece piece): + """Generate all unique orientations of a piece.""" + cdef set orientations_set = set() + cdef list result = [] + cdef list squares = list(piece.squares) + cdef list transformed + cdef int i + + for i in range(4): # 4 rotations (0, 90, 180, 270 degrees) + transformed = rotate_squares_cython(squares, i) + normalized = normalize_squares_cython(transformed) + key = tuple(normalized) + + if key not in orientations_set: + orientations_set.add(key) + corners = compute_corners_cython(normalized) + result.append(PieceOrientation(0, i, normalized, corners)) + + return result + + +cdef list rotate_squares_cython(list squares, int rotations): + """Rotate squares by 90 * rotations degrees.""" + cdef list result = [] + cdef int x, y, i + + for x, y in squares: + for i in range(rotations): + x, y = -y, x # 90 degree rotation + result.append((x, y)) + + return result + + +cdef list normalize_squares_cython(list squares): + """Normalize squares to start at (0, 0).""" + cdef int min_x = min(x for x, _ in squares) + cdef int min_y = min(y for _, y in squares) + + return [(x - min_x, y - min_y) for x, y in squares] + + +cdef list compute_corners_cython(list squares): + """Compute corner squares (diagonal neighbors).""" + cdef set corners = set() + cdef int x, y, dx, dy + + for x, y in squares: + for dx, dy in [(-1, -1), (1, -1), (-1, 1), (1, 1)]: + corners.add((x + dx, y + dy)) + + return list(corners) + + +# ------------------------------------------------------------------- +# Player state +# ------------------------------------------------------------------- + +cdef class PlayerState: + """State for a single player.""" + + cdef public int idx + cdef public set available_pieces + cdef public set corners + cdef public int score + cdef public bint has_started + cdef public bint can_move + + def __init__(self): + self.idx = -1 + self.available_pieces = set() + self.corners = set() + self.score = 0 + self.has_started = False + self.can_move = True + + +# ------------------------------------------------------------------- +# Main Game class +# ------------------------------------------------------------------- + +cdef class BlokusGame: + """Cython-optimized Blokus game engine.""" + + cdef public int board_size + cdef public PieceSet piece_set + cdef public int num_players + cdef public bint corner_rule + cdef public object board + cdef public list players + cdef public int current_player + cdef public int rounds + cdef public bint game_over + cdef public list _action_moves + cdef public dict _move_to_action + cdef public list _actions_by_piece + cdef public list _starting_corners + + def __init__(self, int board_size=20, PieceSet pieces=None, int num_players=4, bint corner_rule=True): + self.board_size = board_size + self.piece_set = pieces or PieceSet(STANDARD_PIECES) + self.num_players = num_players + self.corner_rule = corner_rule + + self.board = Board(board_size) + self.players = [] + self.current_player = 0 + self.rounds = 0 + self.game_over = False + + # Pre-compute all possible moves + self._action_moves = [] + self._move_to_action = {} + self._generate_action_space() + + # Pre-compute action indices per piece + self._actions_by_piece = [] + for piece_id in range(self.piece_set.num_pieces): + self._actions_by_piece.append([ + idx for idx, move in enumerate(self._action_moves) + if move.piece_id == piece_id + ]) + + # Starting corners + max_idx = board_size - 1 + self._starting_corners = [ + (0, 0), + (0, max_idx), + (max_idx, 0), + (max_idx, max_idx), + ] + if num_players == 2: + self._starting_corners = [(0, 0), (max_idx, max_idx)] + elif num_players == 3: + self._starting_corners = [(0, 0), (0, max_idx), (max_idx, 0)] + + # Initialize players + for i in range(self.num_players): + player = PlayerState() + player.idx = i + player.available_pieces = set(self.piece_set.piece_names) + if self.corner_rule and i < len(self._starting_corners): + player.corners = {self._starting_corners[i]} + else: + player.corners = set() + player.score = 0 + player.has_started = False + player.can_move = True + self.players.append(player) + + cdef void _generate_action_space(self): + """Pre-compute all possible (piece, orientation, position) moves.""" + cdef int piece_id, orient_id + cdef PieceOrientation orient + cdef list squares + cdef int max_x, max_y + cdef int px, py + cdef Move move + cdef int action_idx + + self._action_moves = [] + self._move_to_action = {} + + for piece_id in range(self.piece_set.num_pieces): + for orient_id, orient in enumerate(self.piece_set.get_orientations(piece_id)): + squares = orient.squares + max_x = max(x for x, _ in squares) + max_y = max(y for _, y in squares) + + for px in range(self.board_size - max_x): + for py in range(self.board_size - max_y): + move = Move(piece_id, orient_id, px, py) + action_idx = len(self._action_moves) + self._action_moves.append(move) + self._move_to_action[(piece_id, orient_id, px, py)] = action_idx + + @property + def num_actions(self) -> int: + return len(self._action_moves) + + def get_move(self, int action) -> Move: + return self._action_moves[action] + + def get_action(self, Move move) -> int: + return self._move_to_action[(move.piece_id, move.orientation_id, move.x, move.y)] + + def reset(self) -> None: + """Reset the game to its initial state.""" + self.board = Board(self.board_size) + self.players = [] + self.current_player = 0 + self.rounds = 0 + self.game_over = False + + for i in range(self.num_players): + player = PlayerState() + player.idx = i + player.available_pieces = set(self.piece_set.piece_names) + if self.corner_rule and i < len(self._starting_corners): + player.corners = {self._starting_corners[i]} + else: + player.corners = set() + player.score = 0 + player.has_started = False + player.can_move = True + self.players.append(player) + + cdef list _get_placed_squares(self, Move move): + """Get the absolute board coordinates for a move.""" + cdef PieceOrientation orient = self.piece_set.get_orientations(move.piece_id)[move.orientation_id] + cdef list result = [] + cdef int dx, dy + for dx, dy in orient.squares: + result.append((move.x + dx, move.y + dy)) + return result + + cdef list _get_placed_corners(self, Move move): + """Get the absolute corner coordinates for a move.""" + cdef PieceOrientation orient = self.piece_set.get_orientations(move.piece_id)[move.orientation_id] + cdef list result = [] + cdef int dx, dy + for dx, dy in orient.corners: + result.append((move.x + dx, move.y + dy)) + return result + + cpdef bint valid_move(self, int player_idx, Move move): + """Check if a move is valid for the given player.""" + cdef PlayerState player = self.players[player_idx] + cdef Piece piece = self.piece_set.get_piece(move.piece_id) + cdef list placed_squares = self._get_placed_squares(move) + cdef list placed_corners = self._get_placed_corners(move) + cdef int x, y + cdef int player_board_idx = player_idx + 1 + cdef set player_occupied + cdef bint result + + # Rule 1: Check if player has the piece + if piece.name not in player.available_pieces: + return False + + # Rule 2: Check bounds (inline for speed) + for x, y in placed_squares: + if not self.board.in_bounds(x, y): + return False + + # Rule 3: Check overlap + if self.board.has_overlap(placed_squares): + return False + + # Rule 6: First move must be in a corner + if self.corner_rule and not player.has_started: + if len(self.players) <= len(self._starting_corners): + start_corner = self._starting_corners[player_idx] + if (move.x, move.y) != start_corner: + return False + + # Rule 5: No edge adjacency with same-color pieces (inline for speed) + for x, y in placed_squares: + for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: + if self.board.in_bounds(x + dx, y + dy): + if self.board.get_cell(x + dx, y + dy) == player_board_idx: + return False + + # Rule 4: Corner rule (must touch same-color at a corner) + if player.has_started: + player_occupied = self.board.get_player_occupied(player_idx) + # Manual any() implementation - Cython doesn't support generator expressions + result = False + for cx, cy in placed_corners: + if self.board.in_bounds(cx, cy) and (cx, cy) in player_occupied: + result = True + break + if not result: + return False + + return True + + cpdef get_valid_actions(self, int player_idx): + """Get a boolean mask of valid actions for the given player.""" + cdef PlayerState player = self.players[player_idx] + cdef cnp.ndarray mask = np.zeros(self.num_actions, dtype=bool) + cdef list available_piece_ids = [] + cdef int piece_id, action_idx + cdef Move move + cdef list placed_corners, placed_squares + cdef int x, y, player_board_idx = player_idx + 1 + cdef set player_occupied + cdef bint edge_invalid, result + cdef list corners_list + cdef int cx, cy + + # Build available_piece_ids list + for name in player.available_pieces: + available_piece_ids.append(self.piece_set.get_piece_id(name)) + + if not player.can_move: + return mask + + if not player.has_started or not player.corners: + for piece_id in available_piece_ids: + for action_idx in self._actions_by_piece[piece_id]: + if self.valid_move(player_idx, self._action_moves[action_idx]): + mask[action_idx] = True + return mask + + # Pre-compute player's occupied squares ONCE + player_occupied = self.board.get_player_occupied(player_idx + 1) + + for piece_id in available_piece_ids: + for action_idx in self._actions_by_piece[piece_id]: + move = self._action_moves[action_idx] + placed_corners = self._get_placed_corners(move) + + # Early exit: check corner touch (manual any()) + result = False + for cx, cy in placed_corners: + if self.board.in_bounds(cx, cy) and (cx, cy) in player_occupied: + result = True + break + if not result: + continue + + placed_squares = self._get_placed_squares(move) + + # Check bounds + result = True + for x, y in placed_squares: + if not self.board.in_bounds(x, y): + result = False + break + if not result: + continue + + # Check overlap + if self.board.has_overlap(placed_squares): + continue + + # Check edge adjacency (inline for speed) + edge_invalid = False + for x, y in placed_squares: + for dx, dy in [(-1, 0), (1, 0), (0, -1), (0, 1)]: + if self.board.in_bounds(x + dx, y + dy): + if self.board.get_cell(x + dx, y + dy) == player_board_idx: + edge_invalid = True + break + if edge_invalid: + break + + if not edge_invalid: + mask[action_idx] = True + + return mask + + cpdef bint has_valid_moves(self, int player_idx): + """Check if a player has any valid moves.""" + cdef PlayerState player = self.players[player_idx] + cdef list available_piece_ids = [] + cdef int piece_id, action_idx + + # Build available_piece_ids list + for name in player.available_pieces: + available_piece_ids.append(self.piece_set.get_piece_id(name)) + + if not player.can_move: + return False + + for piece_id in available_piece_ids: + for action_idx in self._actions_by_piece[piece_id]: + if self.valid_move(player_idx, self._action_moves[action_idx]): + return True + return False + + def apply_move(self, int player_idx, Move move) -> None: + """Apply a move to the game state. Does not validate.""" + cdef PlayerState player = self.players[player_idx] + cdef Piece piece = self.piece_set.get_piece(move.piece_id) + cdef list placed_squares = self._get_placed_squares(move) + cdef int x, y + + # Place the piece + self.board.place(player_idx + 1, placed_squares) + + # Update player state + player.available_pieces.discard(piece.name) + player.score += piece.size + + # Update corners + if not player.has_started: + player.has_started = True + player.corners = set() + + # Add new corners + cdef list placed_corners = self._get_placed_corners(move) + for x, y in placed_corners: + if self.board.in_bounds(x, y) and self.board.is_empty(x, y): + player.corners.add((x, y)) + + # Check game over + self._check_game_over() + + def play_move(self, int player_idx, int action) -> bint: + """Play an action for the given player. Validates first.""" + cdef Move move = self._action_moves[action] + + if not self.valid_move(player_idx, move): + return False + + self.apply_move(player_idx, move) + return True + + def next_player(self): + """Advance to the next player who can still move. + + If no players can move, the game is over. + """ + if self.game_over: + return self.current_player + + for offset in range(1, self.num_players + 1): + next_idx = (self.current_player + offset) % self.num_players + next_player = self.players[next_idx] + if next_player.can_move and self.has_valid_moves(next_idx): + self.current_player = next_idx + return next_idx + + # No one can move — game over + self.game_over = True + return self.current_player + + def _check_game_over(self) -> None: + """Check if the game is over.""" + cdef PlayerState player + cdef int player_idx + + for player_idx, player in enumerate(self.players): + if not self.has_valid_moves(player_idx): + player.can_move = False + + # Game ends if all players can't move + if all(not p.can_move for p in self.players): + self.game_over = True + elif all(p.has_started and not p.available_pieces for p in self.players): + # All pieces played + self.game_over = True + + def get_state(self) -> dict: + """Get the current game state as a dictionary.""" + return { + "board_size": self.board_size, + "num_players": self.num_players, + "current_player": self.current_player, + "rounds": self.rounds, + "game_over": self.game_over, + "players": [ + { + "idx": p.idx, + "available_pieces": list(p.available_pieces), + "score": p.score, + "has_started": p.has_started, + "can_move": p.can_move, + } + for p in self.players + ], + } + + def copy(self) -> BlokusGame: + """Create a deep copy of the game.""" + cdef BlokusGame new_game = BlokusGame( + board_size=self.board_size, + pieces=self.piece_set, + num_players=self.num_players, + corner_rule=self.corner_rule + ) + + new_game.board = self.board.copy() + new_game.current_player = self.current_player + new_game.rounds = self.rounds + new_game.game_over = self.game_over + + for i, p in enumerate(self.players): + new_game.players[i].available_pieces = p.available_pieces.copy() + new_game.players[i].corners = p.corners.copy() + new_game.players[i].score = p.score + new_game.players[i].has_started = p.has_started + new_game.players[i].can_move = p.can_move + + return new_game diff --git a/src/blokus_gym/core/board.py b/src/blokus_gym/core/board.py index 3760045..3d43c98 100644 --- a/src/blokus_gym/core/board.py +++ b/src/blokus_gym/core/board.py @@ -49,18 +49,20 @@ class Board: """Get the player index at a cell (0 = empty).""" return self.grid[y, x] - def get_player_squares(self, player_idx: int) -> list[tuple[int, int]]: + def get_player_squares(self, player_idx: int, player_board_idx: int | None = None) -> list[tuple[int, int]]: """Get all squares occupied by a player.""" - ys, xs = np.where(self.grid == player_idx) + if player_board_idx is None: + player_board_idx = player_idx + 1 # Default: PLAYER_OFFSET = 1 + ys, xs = np.where(self.grid == player_board_idx) return [(int(x), int(y)) for x, y in zip(xs, ys, strict=True)] - def get_player_occupied(self, player_idx: int) -> set[tuple[int, int]]: + def get_player_occupied(self, player_board_idx: int) -> set[tuple[int, int]]: """Get all squares occupied by a player as a set for fast lookup.""" - if player_idx not in self._occupied_cache: - self._occupied_cache[player_idx] = set(self.get_player_squares(player_idx)) - return self._occupied_cache[player_idx] + if player_board_idx not in self._occupied_cache: + self._occupied_cache[player_board_idx] = set(self.get_player_squares(player_board_idx - 1, player_board_idx)) + return self._occupied_cache[player_board_idx] - def get_player_corners(self, player_idx: int) -> set[tuple[int, int]]: + def get_player_corners(self, player_board_idx: int) -> set[tuple[int, int]]: """Get all corner cells adjacent to a player's pieces. Corner cells are the diagonal neighbors of a player's pieces. @@ -68,7 +70,7 @@ class Board: (corner-to-corner contact rule). """ corners: set[tuple[int, int]] = set() - player_squares = self.get_player_squares(player_idx) + player_squares = self.get_player_squares(player_board_idx - 1, player_board_idx) for x, y in player_squares: for dx, dy in [(-1, -1), (1, -1), (-1, 1), (1, 1)]: cx, cy = x + dx, y + dy diff --git a/src/blokus_gym/core/build/lib.linux-x86_64-cpython-312/blokus_cython.cpython-312-x86_64-linux-gnu.so b/src/blokus_gym/core/build/lib.linux-x86_64-cpython-312/blokus_cython.cpython-312-x86_64-linux-gnu.so new file mode 100755 index 0000000000000000000000000000000000000000..610439f3f80e4d220b10b563e56d3c1054148369 GIT binary patch literal 503280 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 literal 0 HcmV?d00001 diff --git a/src/blokus_gym/core/build/temp.linux-x86_64-cpython-312/blokus_cython.o b/src/blokus_gym/core/build/temp.linux-x86_64-cpython-312/blokus_cython.o new file mode 100644 index 0000000000000000000000000000000000000000..e4a0082e66a60e3b15dc866679e266b83a3e6bf8 GIT binary patch literal 740008 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

    ^N&5);I5Ygf&FIq%} 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 #@49xb5; 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
  • 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Ŕ| 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

    • t7?> z>wkstN$A)0!oB{BiF5t$Aa4EYMZcB__xk@txcBQp;oh$&g-=G#=Y{v;`-N4)N0H|Z z;WM#*ct^M|cOMG(JpWXVJlo(3KjiS4m^;l0RnweWi6zd^WvFZdndp8to!rz7XX!adL9!u@y5pB6qF)Au>yEAYAb zig3^Kx^S=0hr-K|^Pj>!=cL_it+8RfF&BAu5Z;P?7Rs945RHc}`M}={Q?> zE%KZzd^z%5DBSa0DctkiAbckB+%DYfbC+=c9Pbc59r+&??&lx$2=_cs3$OI~LHHon z5C1LP`@35BAm*R9g!^*6PWX|?U%31D`C%67Q!L!;v%7F#kL@qq+btJfj{fG9BhN{~ zy}zdk_j=A1?$^UK3U~dr!u@-wTT*zN@Mh$17v7Hb=L5=dy+n`jTGY8;xaS-Y?)86D zxaVIZyb(Fq3wNK-gipu*@}}AG^MluaitxF}f1q&BUm?5zc}^7W-y5DHd@+{yIl?{9 zrNZlxXOVFKTxb#QIlnL5^V}u871Q^A;p@<^e-}O%_3Rez`JWZui2Sb!_wBSdi1T*Z zTH>}nvlMwg6h4UM>l5L=J@bWdug?T)EDXM#;M-|i3-|4`J%u-;Uk3~K?X<&*+rNHX zK`P+nh{vQeV`J_X52l78G z-19$1ob&%DanAp$@DAjESGebYU%2Q0yYO<<{|n*Ek$=LT$?PyTKY0GFh;#m8;+%hf z;a$jolyJ{KQ@H0pUHDAouMysh{O1ez{PT!&{)NOj|96EiNB%p7d;WWcd;SN7S0ev^ z2w#l+PYCz?PZ8(*{lq!{o5FjM|8sED@_BtbO^wrC`3&NG{ck<-m0=`5FY#^Stlx64 z@$=OzoHsBTJXmCIBcGQ@ziD`H+TkpUwA){jk2Wep_&>+dbs7JLzp4Kacca;%AZmDDvU^7+gU5uaSNMacjGE zlkgCR?~xBrucf3vn|#_y&+Yb+-hMLL=aZGhtzEyr{|Ch9kp5HRrf)~iT}mx&oOjM4 z{oce)@AvmViTJssKa;rWyWrnQ+|JSV{4K;y@Avn=kGTExvFjfpZu(yMzeM~z(!WmJ z^nQQ;&xoH-`ic7nQ5b9YigT&{Oel2m+uZMnuE$CseI?N;ecEn9T3jGY?7nA-7;->fe@_Y^4 z7%vxdNzcpaLU4P!p8T&Ry?M>W`5CtguLZwH_-yb_;j_S>6h0IDIpLMyuL&;)Un6`v z`2Pu?3cl%np)+Cd`LG0hJK>YTv%)8VA0WH{{Al6+yAh`d_urqW74E-dak=m{IFIUE z!Uw@`5xxq1nedh14+>ua{tMx~;Li$Q4!%mbpMUnQ@DAwzCcGVdlj-B9%Tn+n;jQ4i z3ttRALwGazQNkO+zXEQv3(x;&ioPED3x&@Gze;#5c#H7a;I|8(1^#2d^#-lS?j-&_;y)vwfv__0&%xi2p6^ff2jX@un(NmP{~__oGh%%L%DhQ@KjM6S zP&K%%mw5er3F&!#-k75QL5lvt6#hrzf1;f4lm8{e|3><^h)+0RLw{c(K7}~vpF#ZF zq(6x`>ubS%y?IpzLlTSVQ{FwN)#Cdw%4sPp#A=2MX`cC2<#QDB?4})9IOG)2N zdd~A3(qBgU7fH|i3;#o$>+^ST%l|g{6qLp3V*DNATY+0n`-ym;pLYNcXx#qMLBzS; zV~M{@K2_vzULBZT=aZg&E>6)e1lRnFNMBFw-bntuf47wMoTr2M0`hqTT-$w;{CWTD zcPaWmlK&Ot|89!UI?{8_&r|#h4h+Q&gH1>K33{K7lfcb`>+mIT?N^q38px+K#peL> zd5ZLhl8@cv&hs3d;&VK4ULMaRf4kP!eZEe5zHiKB#M$S1@T5NBp(J?O&`R9UOniQ=8`J6IgL;X(#xBA#U zBz?M^AwFv`pPZB8bA{-=-9;(-pNQW5A0(diYuhA#=2_y_uT{wNyA=NqQuH4aXa9mj zVmrpne-QpfDZH4tjpNht1mc|YV&U$8Ik;(0rRlPW_>t@3>#z%PuER9qT!$lwv%Z!% z>lc9Q`l<=sayC-^Zz3OFZ`@0I8^@Q&juhUN!k4G;-W2{C@nkys@hjr?IWma#=DWmA zzjUYY5Qg`OTmJSt5}f&nIQx$X@34`=P;^*)wwLU`vvAk%lfn;6;YSM}ER5})Al&bV z{1tG^Qc26#S)%tm^N1&(zu5k+CvIL{=x=ihzgc+u7BT0o%2EH@!8PZPMeprCPTX>q zV1Mu_&0>FN6zbnd(NA{HRm0o_jZ3u z+;R@$`@b&Y=Cu+z`%?Jx!u`IAFA4XYuYzmNcSP^)ej>aC>!r_$Tf~*`#-Ig3C;DSIGg)S5;gc#N-&6RkFCw2t-0D_~^YD%!ZvK^LME$YEEzc@@GYnP2 zybldG^~9H~kvu_att5zYb~|anrAZ{%GQ+ zAKW>-8HN*xn|?j?bBLS167yjlanp}N-$>l_e*OQo#7$oiXRFNZ#7#fCeRwkrcM&)J zBM`P`pA7x8!bi#}9?qJ`wfz3-5i!TFqo07hd~nc4_`;=g$`dXc#KcfkKG;oh(JguDMgQusDUMMIyyu0Kq;f4*D_ zuKQmNq`xKv_5I%_aLdleiFxQ|0UA%_gSxrelhg_ z1h=}KK{>ZLCV()Q_nE|Z1NXX>Z=J|8dkOdBe$$2f^gWRLdHd=((sTV!A^mL1Gl%q+ zbm>XjRReL;d!B2_|7YP1uYarPm*V)+9mLsx8FBMpIyvU)6g~@edxSXq zEGKS0t?*ePyb?Yy5NDqO;^wm$K10G+Vf*3F#Mx&Zar0@0U(*zemU7erw&5B4d{ z8QrkI(+Hp9T!P28i&h}duEg1ADsjtG51&K8Eyn%f4WEvcqAx++<_WLF=g2pOw}M|U zd@gt|xMlf0wfhn2E&oa^ZzIHQoDOVnOgJ{Y2!m;jd!2V9Zto2?hKDd5NZj;(J=EdE zO<#-o_B?RY-W?viKJ!R#@6~P@9>TDIIQx7*#peg4Hy=NbqCJIor}+Ge^hvwee_4^j zf1kqFrtskuo;fb*_Sk&u$1^8_+j^4EtJ#V4+}~YO_<`W2<@%pY`c18F=f)hTlAhpWxoO4Iw*7iDlK9;2LGH}y!&cj9TInNNj964)=bIwJ?Ip?>D zTia`pvo(e1!8PYYqAv+vHasSL5dOa)pR*=xSYCcDdiQxIMgM~6r^aS8FQw>T6a94P zUr*7$E&6ik-%HVdAbRYsX8x9<|5Wrd;r~U7e!_`SVAIy7!7S*v1UJU@{F3O~QU9#) z+3?wieE9S37}8tY{&{yIackQ@?@kf!pD$++Hy{7Jn@5~|>V^A${hi>Z<>lpG(fjAr zeZoD@&xmuLCx}}c?$ayW^SlMFdHzcJ#2=q`BPo31NujYYn3nasr0{)G_%Xu$^KK@% z<>cvGD|(;47ZJB{yl(S}Th2jj&tFHJ^=-n};W+RE!o8lq0ymG2@Zj6Y&yt?&^FO5L z`Qfjm=RBKK1>-Q7hjGudy>Q>2*&AH*97uZ3a~kP6&zuzfi$y_s;gNR!j%b`D9xceUqZd%S+N1StBB0e)ijcm9=xch&L zxYcw2bA9#_zP>QFR|l^By+ri0Q0FUzd)lB_qzRwxYey4b^9}MuG>1{{`;4Eel@nE zb(;q6({U1(qXUI|-OfqzIiEP!ZK3#h-4+S=y4^@VT(>sS*P?EBE8isc^8w;kw`SDs zA>v%O$Ap(-xmX9Tb^AZj4`RRjAHuzEQ?MbYK6?}Ax*ZPg)5YtS6Yh1ZA|I~X*`l9| zx}7K7=eNsv$O6OY!+%;#{{c#Ap4a z=riGz`0Vxcx@`?^Ik|2nqOV8Y_7v`QJAk;=trB%RlsMPzDCMYI6S&sx2GLidU*8e# z^V=gSK93XUx;-mC)3=WGS}EM?wu*eXZtse|5p{cCxYz9y;#Rj3)a`TPT(^Q#$4|$p zsN0d?TDRjw-;BDQEZpn1FvaJa#JO&_iqCZa{zACd?H=;sx^;@a8FhP9xYz9|;#Rj& zd@ueCajx47!b?!Mg41F>wQgI1`|{F=x@|Aq>vnjG&(XxWZl{Zn*R4jl*R76xxNcX9 zelhCy4dGt5n}}Q8{Jex)h;!ZAgil7@o(I>uy(Id2)a^ClUbin&d^W4zFkQHAJAwOj z@w)9Q-0QX%`EcFJMc<0L9Vy)Fb`o)`TQBCfQ;Bok&JsQeb!!9Hy4@}MS*Y8Og?rte zP4W3Hajx5&;^UvEYlM5<){zg_?K9CYMcp<%ef)aK>$VMXt6Mwjwj*(_TZ!Gd3(oynnYRxGzVGw~D%H!o6;%r})&U9{oCBxcBRF;?}QP^lKq; z?$;vWYtXNIiSzN^pAk17zaHcf;oh%R;5uKuA^I-#>mA|VufGzvepRAh9~0+(jS63f ze(ic@oDMc!xL^AcH=kLU-^zr0zs?5New`=!<>=Qu;oh&Sh+Dr((61)q+^-vicVPLw zTewe`9}DlYj)&n{aLvC`^u5Ucs&LQ$7IDk(=S{vxob!JmybJj!-~h74GriY;l5o#| zFu3MFLi8(;|5)Lk{}keue-P(=&L+|6}5u|EI#IBmb|3d;M1k z_x%40uK9EioeTMGB>lkLIHpFd}(h<**~Q!3o+Q%>CKQ;Yf>Nu29* zobXAg&mwT`Z;R+>WBcK|!dFQ;%mWzLTM@agEsdnXE?jJh2Mu5~+E^tGs4wQ#T7H&c9?iF4g<7au=Pa+h$g z+mFeI>-LD~*Q0LBg?rulh+ExCP`Bra^ZfRb@DkK*LQSl*)@>5F*MBbRwu5l5TV;yR z@uD9^zrG^e`}H;A)~``qm-2Pu+^@O9M={?v3-|Tp&B8tZL*QD6$3$PSd8}8DaL>Pj zxaA*2{uhaJ{#TS^y1Xyk*OMO!_x#0kHa;D92lwgd_hFby+};~(isK(f+;Yy{De|LJ z_!;0@w>hGpYJxDFN1WTeinvK@(QZ=;Zw1$O?-V^Q^U5qE&h0)-+`ML^-N#e-bKu(U z??hi|f-t;7oZI~~ag)wMyX#VT=A6XtU%m&N2yWhq589nXoZH=&zo6+ui;@s}Ub3t5SF^xVC$d=$E41`NX;1Yl)k5GTOZE>D?ia+l-R-^}8ViFllMbTY;uJm| zT-!ZZ^y|=W1#xcotHe#Z3hkbe!Y>Bbb{B|#J=$GJoZJ02ag(k@yR9ia53cP#DEd*f z+eMt)eVVvQSD@YJQuyoO+V0z;pNs9@FNFJk^w#Hv#=_v!*SG6-CZ6PMjJk5-1$3Tv zj(L#wBL7J#{9JI&f1&8>k^gexp8po%zI}Knan9dOob&fG5BZlP|8G+GAHX&LpG4n? z{O=3*{1eWPb@lrDcILLkIsbIxoWFv3uKrQz`sqaLvD3^q%u0;mw#Xp9}Zx-idV^rVHnvN}ThTF%P4*BmZG3 z{Hx%af41m7{{rEy$iGOqZ$IBmob%_2bN(*onQ&er^8Y-AKM$_?2So4r{~~-Y=Btl| z`*!$0iF5vv3o^-IjPsW=5AU@i{{bodcyP@>OZ1+9p77bof0c0Gp1+nj=U+yg^LH>0 z`4=Pq!zuh}aLwN@de8s1@D-SUJ`nEv1%D^b`6pkPls|r6(E2~iJV=_6f1eb7B)H~3 zPV|eB^EBb!ugiq{{zW74O+y~P&gc%}T>l?25Bf&r??~Z2;F|ww(Jw{*mBKy${|NW} zl#hsSO8K|BD7*-RG0wjW^YC6h@=r{IPPpg)y6{o7dkJyQznD1Jzm0jwG#fs5r|^ft3nc&JqHje0r-gg|*M+Y~ zyK9JZ{!QkE2E(BB-)_)T7@O~wHc1Yp-fNTC4 zqVGcflZAW!vxE<#-Sdfa{$}D_|0T>r{&M)-p28mh*ZdEOz834Bp9}Z=|1EqK+I@pK z=N}=?`3o+wse2bnmB7c?eS>UG%pA9}+crExj!smk539kpgM0h*+0^yC| zjlw&?za_jG{6^tj;NKO#82tOfmxC`A-U|Lh;l1GZ3115SYvGf@SETUO;5z@jCHhI5 z+uRq<^B3;lOa6_xeJ|O2c+`JN+}iN(*)x~M_kDh@#QLFFxPPy@yYQ7ZVi-;Y*Zil5 zelqgU7Vi1$h+F=4ajQ==>Qiu8Y~QD&Pv5PCw--j;iQwAbQ$#-#=L5_Z zz6#U*+7zD_;#{{o#mCR1xL3H>?SAs%x;-ZPsi<3zaIf16;#Rj>)a^y$JYT&cd@1U- z#pSVnTDKx_uYWn}wzF`rTQ0@t1maw`8u97fBIY<>xYz9x^5MFDL-f;8x9fy^-EJXn zb*n_(+K6-A?iRihb$bO|>-I;{uiqy2Ye=})ZDRe#>%R^7SpCtj9ffQlNVwD%aMOi<&)z0(}a8e)4?_W z*NF3Scd7XJa@Qc-m%AqN;pOhTqMwEOd|$ZN=U(DgpI+4GKH@xmJB2Ssecl4s{=O&r z!7XFmJ`nD8+v$qvk0RaNTB!em3fMrf{#@`NXYm?Wo(u z#JO$@gs(u|I>EKSkBYv0n^>1$2=}_Znd0*fajx6P;^Xt%sBo`a!Ic}P3)gK2aIb$Y z>b8sWP2%`_6SulGqi*{X=em^(??v4%2iLkS6n*>FvE4<&y>9oX_&i9Q>-H=0@w)w& zaIf176GL_*_Ap>vp5~bisd#aIae%`EcESBKmsN?PtQhZjTeUx>cfXza-9e>l5CAy8Rto z=eI9JzZjnj6RwK&^Ll#SW`L{D!Nj?4CyGxk@|+^v>vk6TaNXvLz7ci1T)5Zmo5Zbd zC8*o=#JO(Y7T$`Sec;;P=S4pk^TSKRy>1_;_>79a8U5O9;rRM{zqTcA{Te+i>UJW| z{n}OdT=eS@;lAHmDctj41g>?sO!SM9|0?00|2pE9e-QZ>6X*Q539m=~2ZZ~6>qEjl z|9^vP{?(#yMgF&hd;Yb=Eq^cae@LA3ef98zIwy-&- zA0^z|Jpo+%HJ3Q|>vHkwMZXpbcmHdNTfasRjdi(+IQQ!o;fv9)`%-wPaBsI8T>JGh zaqibD;=JARKjPoMZOs2y;oj~ivpn4He&C@ru<(>Y5tNFesBt}N#S!-_$?{?rz!luQuv!Gd|e9PtZC!@EluI& zDSS=}zb1v>k-{HI;k_yR)f7IG!V4B{yubUV@Doz_1u6Wx6yBP`A4uW-DSTB5|1^c~ z_^pli_rMf>N(!${;a8{dWhuNPg};!(|D3`%xpw3I+BJnwPvOU>@N?@=lI zY~nn9FHYg#OX2M){5Qn;^XttN{`VBV-Sr#q*M2GdgcN>$3SX4M?@Zy3r10lc_}eM` zvlPDL4IA(80V(|C6n;?(zb=K}ox&eW;V-7}Kd11266g7Co0bjzWqwEspP9lJ5a;>r zmK44$g+H3YSEcZw6h7g`Ofu+p)RYu{R0^My!sn;(8&Y^j3hz$guch#}Q~2gLZM?tR zr|`p4`0*)xehOcl!t*KI?+3hTh|BZIiz)hdQuxH1H{RbJQg}rQpPj-RQg~|$|6vM$ zJca)ug}yecByP)q|DMj%Df~I&1wsGAonrq7grB=fi8~S?{`TUgH{XXgK_=#VS{Da_WgL&Uc`a8+z>Mp^ z#dyQ`Rn|ESSv#G4c|*S>Z9^w<5o&SP~G{qXV8$lGzf&xcD$Z}qQ3{kw%<1D>p? zg3f&o!E`LN6&SeX?8bamOx&hd-t!C3Unh=Oc=qmFyr#G5bt$G-zvzeNnIbG-#7%!W^uxrhzh&!8 z9oA=9{@j0S=!%J(z6JUU;^yA~{~Yn8o_{s>FkcWieG~NaiJQLrLsMrmONg8PX6W09 zn|}BsQ-|@0n|=xOJ;Y6)`NRYTnTe}vaQADNHovwMVxFnGP4cOM`52>F;k zgSusKexK{hYNEcBxUC z)3t}V`47Q=fOz6RHTu_J|G<5U;J;dU9i~UkPH{ZXUvzkU-9S9?-z)MF;dyKqHtoE@ z$Mgg6A0ck}bMP-J9JSF`y%g>=NBX0WK zQ&CqTybZjXxcL;~^Q?xr`E=*PLm29^$y3s<@uFueS=heICQoB|wues(ant929d%2D z4}<54Tb|wE(@ETX26Evc4Bgq}X)I5sFTU<4Za&lCGeF#YGRN9On2)l_)0oc?mfKQmcoBw8!e7$gK6@3`!^F*}0zO&drf>K!Q-|p*ybs)uw`~$M=5rE! zszg8V8*>TsweakU$mbI`pHtz}K-}`=j*a>z;bqT7-bUPfYT&bsc+xNUTZo&FZ)Ywcp7?AUee%Rj@7tN3 z#1m!dX5rm%oSC@k@Adf~+htZQ(+|uD4`FB{ZhHT{*JZ>L|7f4d3(udM*kt;N+vjY4 z@5omRZ^8CkA)Y-?_Los#EWG=i$bCH1Th5o!uO*^yc`WMNgb#ps5;vb$;nPjr`a67F z^yv{k^z+CEh?`F-mY3DU&8O)2s2>vEy*%;};^wmkc`~S<*Qe!)s4o;g0G=goKJUY) zl(^+-L%+&|4?P+EtB9M=C-A8zZa#hRsS)1N6McO8`}Fepyi@cIpP3@~5w~`IKJO=P z?dD#N`eNHi4TJmt6FGhR-MH!V2bd~+Zjj#oEyea^4{_7C*+Urmgm+&Q`C8&OpZDz> z`H1j5w)0Ez?0JSBi3?JN@VbiV;-v zfKRpXA^6NEZayc$r-8Wnba#b^Ff<9zJQBH2XP+()PmH`@^tldGg!MgfYj>-{1ZUO~ zw|1-dw#P7Fzs>y*-y-5d;-(yUA?mZl&EJ==QsSm8`#9#w5jVXrUsc2t|2?ArGUACI zb?YW>%AvCG5QZ}B7g}q!DAZy3svvIqhG?J32_HH;ycvf1#FOO<`-4rwv*4Y?&AR)T z*g%i);W>$Y#>ewI`|-+B_!&2c+=EeHMcnF;kLAo%6E}Ss*7G&Ohv3sd+ekdQgZy%Z7{LAi(d@bqC=NkA76E}VCfv6u5-UeQT{&^msABu^aPaEck ztnmC#qkjc)%j4T2IpXHi0G}%5KZ`#8Iq7+PzUmbH08Vh|BhK?xKXGe!;9+wN`_WiW zxW8ZDR7TwNML4ckBRpFfeY%O;{FXV=9>V-g+~yzuK6FHQ9`kJ}p3T+T&D{|FD})c# zn0r_bi1Yl@N!)zu?oQ;HZsFbF{lt0x86a*xefLD4)xwMJjeMB6`P_~9aD=$|WZR=Y zb5MNt{x*OY6E~lG;FBe8J}p0vXDp1A4#^Qe<}QU|PX zM~IvLhsarUaLncX8onyNZX<5TU?2qlePU4Br^Y$2y{}4ByJbe0yo6p0@(@)$S>Q0GyRuea$I`|9`H=l1M`2N7pXEc@Nc?R_ge;-+l4E9!@co8Ifc zmUyDXal8zU2YCH``W6y5eGbP7v&7Bck5Bq}bLNxiaeT6Z^i#rneta@V+`S|hVJn_T_ z>!nWO=Hth=dx)ElAK&gHZa!nj+liac*ztDa=F^Ac$wS1==W*0|EphYdyC^PSBgD-o zgX901!|la}<@B^I@tiDi^Y`OLeq7V_ ze!M6rdOsdjMcn-TcvKy6^Y`Oj^NE|@k9V~Y=l(7sp6GF$Ay3@&-rr8*ruX9*eZ<+n zpSbCLe{+a9`>!RQ=>3F!>>qgjeSRn;Zu-8wDZ=&+arQ4IZhGI}$r0!LRm4s2pTBj) z*?&Iq#2=sUEyPVfwp~Fy(ff7<@hO(mw=0O7k8kI65;va)Z0Gb4Hy_{5=_77FzTMSN z+Z4;m>@=wo8ed&)9Y;aq}61 zPnNj(_;zwBar5!*@o>!}&PL zW7H@7)Ch`&_u=yzo2QAtUlU&*0K%T7dzOP5)3gYJD*8}E=vrm<9_o*XpK7QRF4#y;u$$VO{UD`l; z<2mG6Lfm{FK)>3E-xoL0!n@&k67e}SeY=U9&m-{ZA1!eE^BrNmADGW2D{?cYB5V|Q-Me-Qeb6nztM^Y`=STZr4gL-5ZN zH~rt>-$|VH{lrcG8T13h?ccIp!b2EvIBcvAedk3!OnUR#Vp8NI#MvhkcN_l2r;#`Iar5c>QuO!TQJ*d?=SQ9+z4`0~pDN->p6jFD&(n0D;R_?5PkQt5>*E@Tn@=5l znuM2SqfZ-g^EnQAmJv6f>cvs-k3JvzecH2l!?gD20}gX0%y<#rsKT@B@pVI{R(Kw- z8-(X9Ko~rh`wWBo`qp{Y{t3fCd>YHs0KP_e8+Zx)+{fn+Tt+qKocZ1Iop26~4Cp-)8^NIVkfOm;L z58fxd4}6vIA@H@riwfg}8Wr9KUWEF2o;E)YBiy$iT7>&`*-M4{b>*GH{kkT<&feSY z#`acV%)u}PSo?$d_lajNh>@Fl|ix}A36MgF~p@GST$;dR@_IjL~f&CdON{xeidQ< zGJmT-HlxPA2ljUTdfrOX+j|*o|I`Tg?V?8EejT^Z?_>Tun%Rc^D(C)v?t1dEoC^|l z_`NdB@2=196yNasPdl&MIr6;d+rZZe_wyyDV!3f2KR>)ycr`xnnuYu4U|zU?Uifex0fR4uk7kpfAMoYTWAlb*z_X61VsK zbF*1^Zc40kkMQgsk*^l+*DLvTg`TH-&!{iO@;%0ZgSQJmbMMf27}f|sV4ui~wu{f^Z+~U@-etP* zY(>=h`rGw&;B!Uq$MKg4Z^LokLE+svJ~d3->UO0)grQ*j`0VZa@vl0{`&rr4-0>7M&u>TX+Nb3gKZd_7(G0C=_X>Zos2etP6R!u`HI71$2)cKtjk z-#&6acD}CY{rdeD;eK4suah0~sfl^IMDN${_Y3#)rq&4e^LsPc{&Igm|FcB6UsvMS z;kv%)+?c09^nRU7r*J=i)xSS?AHNTne;@ALkK<*(9NTg3#|d-7$L{wf+>Z;j3isnP zJ;HN!vAvbT`!0ywzfbl&exH_#lJPnHxJ{jKzdmA_^0{&R6~f!*MP9V)c>ke`$592xgzCDw${p-BCKKhgiZ&?tze}Ce7zYo=7(fj?c{Cg7D`+0^dMDO<_S}%O4 zF}7Q82dBc|K0{6Mb*u1}MUk%*p8Hnhle6*Jed?}_ugioFf!7N!yFTh$g!^%}F5%f5 zqJBVlrX}+A!Uw>oPl@k)&c2)C>t^A8T+Xj2b$#YLQ9o&q@jgYj#@7|X8*YQY@XYrj zUn4w!N8}}Y#^+7Lll}SmmX*T&e9L;_e%|9U;eI}Fk8nR9c&%_h@3(O3_&k2zZ-sC_ zzqdxXpWnMgxSz+{DcsNF_3QP#4nz5vV?^|RK71+m+g$JGy;lkM^WK|;`+4jg!W(`T z+x6@0#{3_Qym0UM?A))jC>QS6N!1JY>z0ufhK2ieMkUzK@H~D!QKfLd zo~T}U(W9|Hem$D|`1OpdMeo-$7Ggix^?rR~xp2SUuuiyNSJ)!luPgNZ>@oi*W6nX* z`*nYX`;MP3eqEIRj+9JwD~aUZ{bQR)8U{r$c@Rl@!L zPRoV&y%NV?C%o>}$Sbj5>+KG|9(k>BzdznG;oWaV{TktZA3VQK$Nl}jbAEk|^MUuH z&*B5(vva?nTZeGJZ`+XY%wOa9C1vA%{61{;!u@`0t-}4jYF)zp{%Pxl`+d@K2aa#I z@8kHoP596!k@pF2`!w>*LF0XfM&s*h;eP&1kMMzlO_C7`4;CMszg;f8Zp)}|6z=CQ z`E?&YU50U9)3E6MeC(3)@$LF~j7`EDietMgl;ge!C5Mdn$?P8Wem#Qc>Dwdn<)ZJ~ zEAnCCMf*gaJ9NDN*!?7h`+X_>JaBK<@BfxPY`l-(N3L49-{;EDmv$e&U)E~TXUb#F z$ra=M$Ifq2j`K_w3-|l|`gy$Gu3sHRkd2Je~XbSEWac&*|qc zwFw`)FXfTr^?tulzYfX$hv&q07mMDnXIUYCBwy^UI=^v?^E_}zgLmjQ8>T0WJ~VQnFbh92TCz33N4c#{2knbE}1S9~gZ~&l#`x-y^6MUQ`kFUBU;B zjeJyi8}4geb?$io+!;~7Ot@cvxZfu~f8hpy^ZD*~;_J+es~0V3yx_v{+_*44 z&-ecp&a1y*M&rDu#>|Yl7c^dwnQ`IOS7&A{ywYBn{J@xViaYV1{L>Y^(bESPsiNP5MUjq_%l zbn03AU)^}YMVI6CC0ATCqhaBd4f7T@dW3oN&%b!#1qvG!Jln&&;F0Sw0Gjr za$Bt1qf?y3=j`~GN!>P9zq)s}NR)nFlGV$mk@w&0XPXz+zUD7`B(`6Q{h}aA1|Q$^ zUl6GMuhYNgFLC_4zZ1vvM<35$+iGxQ`CAIMOeFLF7?qaSdgSeU{%Zm=Pn~|5h6#aY zGTEb&r?H3Z*njb#hVZnp_Se1{+xP3#t-Yj>c`$%kmNP=a9o`-LT7aME8 zZnCu&t_z4Z$^5=`c&+W<6WGSu&pZ}KoNp#HWa)qVcWLV*6fad)_wuY5QG) zS^L|EKOP#;ei_5?zc2s({Hwq=Hhv!Cd;4zV?fdid7+>4z!T2+LL_AwtHu&=Z{hz#n zhxaf(GyC7ib3PRQu{D)0ziTmmHoV7!=XN#{{xMG-zwq%m{kku7Wqj80|1aQ;O}}DH zKfnK-)zMaEKEBs=V{KbYJ(J@S-OysMGMO)hKU*d0__j>SEN=2l=?~)gO*bVk#~!qP V+l6;FHvZ6YasJy>Mv#}8{|EX*V`KmT literal 0 HcmV?d00001 diff --git a/src/blokus_gym/core/game.py b/src/blokus_gym/core/game.py index 644bdb8..c4422d4 100644 --- a/src/blokus_gym/core/game.py +++ b/src/blokus_gym/core/game.py @@ -207,7 +207,7 @@ class BlokusGame: if player.has_started: placed_corners = self._get_placed_corners(move) # Use cached occupied squares from board for fast lookup - player_occupied = self.board.get_player_occupied(player_idx) + player_occupied = self.board.get_player_occupied(player_board_idx) touches_corner = any( self.board.in_bounds(cx, cy) and (cx, cy) in player_occupied for cx, cy in placed_corners @@ -240,7 +240,7 @@ class BlokusGame: player_board_idx = player_idx + self.PLAYER_OFFSET # Pre-compute player's occupied squares ONCE (cached) - player_occupied = self.board.get_player_occupied(player_idx) + player_occupied = self.board.get_player_occupied(player_board_idx) for piece_id in available_piece_ids: for action_idx in self._actions_by_piece[piece_id]: diff --git a/src/blokus_gym/core/setup_cython.py b/src/blokus_gym/core/setup_cython.py new file mode 100644 index 0000000..ce951ea --- /dev/null +++ b/src/blokus_gym/core/setup_cython.py @@ -0,0 +1,25 @@ +#!/usr/bin/env python3 +"""Setup script for compiling Cython extensions.""" + +from setuptools import setup, Extension +from Cython.Build import cythonize +import numpy as np + +# Define extensions with proper include directories +extensions = [ + Extension( + "blokus_cython", + ["blokus_cython.pyx"], + include_dirs=[np.get_include()], + define_macros=[("NPY_NO_DEPRECATED_API", "NPY_1_7_API_VERSION")], + ), +] + +setup( + ext_modules=cythonize( + extensions, + compiler_directives={"language_level": "3"}, + annotate=False, + ), + include_dirs=[np.get_include()], +) diff --git a/src/build/lib.linux-x86_64-cpython-312/blokus_gym/core/blokus_cython.cpython-312-x86_64-linux-gnu.so b/src/build/lib.linux-x86_64-cpython-312/blokus_gym/core/blokus_cython.cpython-312-x86_64-linux-gnu.so new file mode 100755 index 0000000000000000000000000000000000000000..71661367d673fc6a70c9aa3c1ae147e587fc288d GIT binary patch literal 513456 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